deno.land / std@0.166.0 / node / internal / buffer.d.ts
نووسراو ببینە
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.// Copyright DefinitelyTyped contributors. All rights reserved. MIT license.
/** * One of many allowed encodings for the buffer content * - ascii * - base64 * - base64url * - binary * - hex * - latin1 * - ucs-2 * - ucs2 * - utf-8 * - utf16le * - utf8 */type Encoding = unknown;
type WithImplicitCoercion<T> = | T | { valueOf(): T; };
/** * `Buffer` objects are used to represent a fixed-length sequence of bytes. Many * Node.js APIs support `Buffer`s. * * The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and * extends it with methods that cover additional use cases. Node.js APIs accept * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well. * * While the `Buffer` class is available within the global scope, it is still * recommended to explicitly reference it via an import or require statement. * * ```js * import { Buffer } from 'buffer'; * * // Creates a zero-filled Buffer of length 10. * const buf1 = Buffer.alloc(10); * * // Creates a Buffer of length 10, * // filled with bytes which all have the value `1`. * const buf2 = Buffer.alloc(10, 1); * * // Creates an uninitialized buffer of length 10. * // This is faster than calling Buffer.alloc() but the returned * // Buffer instance might contain old data that needs to be * // overwritten using fill(), write(), or other functions that fill the Buffer's * // contents. * const buf3 = Buffer.allocUnsafe(10); * * // Creates a Buffer containing the bytes [1, 2, 3]. * const buf4 = Buffer.from([1, 2, 3]); * * // Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries * // are all truncated using `(value & 255)` to fit into the range 0–255. * const buf5 = Buffer.from([257, 257.5, -255, '1']); * * // Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést': * // [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation) * // [116, 195, 169, 115, 116] (in decimal notation) * const buf6 = Buffer.from('tést'); * * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74]. * const buf7 = Buffer.from('tést', 'latin1'); * ``` * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/buffer.js) */export class Buffer extends Uint8Array { /** * Allocates a new buffer containing the given {str}. * * @param str String to store in buffer. * @param encoding encoding to use, optional. Default is 'utf8' * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead. */ constructor(str: string, encoding?: Encoding); /** * Allocates a new buffer of {size} octets. * * @param size count of octets to allocate. * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`). */ constructor(size: number); /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead. */ constructor(array: Uint8Array); /** * Produces a Buffer backed by the same allocated memory as * the given {ArrayBuffer}/{SharedArrayBuffer}. * * @param arrayBuffer The ArrayBuffer with which to share memory. * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead. */ constructor(arrayBuffer: ArrayBuffer | SharedArrayBuffer); /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead. */ constructor(array: ReadonlyArray<unknown>); /** * Copies the passed {buffer} data onto a new {Buffer} instance. * * @param buffer The buffer to copy. * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead. */ constructor(buffer: Buffer); /** * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`. * Array entries outside that range will be truncated to fit into it. * * ```js * import { Buffer } from 'buffer'; * * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'. * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); * ``` * * A `TypeError` will be thrown if `array` is not an `Array` or another type * appropriate for `Buffer.from()` variants. * * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does. * @since v5.10.0 */ static from( arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number, ): Buffer; /** * Creates a new Buffer using the passed {data} * @param data data to create a new Buffer */ static from(data: Uint8Array | ReadonlyArray<number>): Buffer; static from( data: WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>, ): Buffer; /** * Creates a new Buffer containing the given JavaScript string {str}. * If provided, the {encoding} parameter identifies the character encoding. * If not provided, {encoding} defaults to 'utf8'. */ static from( str: | WithImplicitCoercion<string> | { [Symbol.toPrimitive](hint: "string"): string; }, encoding?: Encoding, ): Buffer; /** * Creates a new Buffer using the passed {data} * @param values to create a new Buffer */ static of(...items: number[]): Buffer; /** * Returns `true` if `obj` is a `Buffer`, `false` otherwise. * * ```js * import { Buffer } from 'buffer'; * * Buffer.isBuffer(Buffer.alloc(10)); // true * Buffer.isBuffer(Buffer.from('foo')); // true * Buffer.isBuffer('a string'); // false * Buffer.isBuffer([]); // false * Buffer.isBuffer(new Uint8Array(1024)); // false * ``` * @since v0.1.101 */ static isBuffer(obj: unknown): obj is Buffer; /** * Returns `true` if `encoding` is the name of a supported character encoding, * or `false` otherwise. * * ```js * import { Buffer } from 'buffer'; * * console.log(Buffer.isEncoding('utf8')); * // Prints: true * * console.log(Buffer.isEncoding('hex')); * // Prints: true * * console.log(Buffer.isEncoding('utf/8')); * // Prints: false * * console.log(Buffer.isEncoding('')); * // Prints: false * ``` * @since v0.9.1 * @param encoding A character encoding name to check. */ static isEncoding(encoding: string): boolean; /** * Returns the byte length of a string when encoded using `encoding`. * This is not the same as [`String.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length), which does not account * for the encoding that is used to convert the string into bytes. * * For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input. * For strings that contain non-base64/hex-encoded data (e.g. whitespace), the * return value might be greater than the length of a `Buffer` created from the * string. * * ```js * import { Buffer } from 'buffer'; * * const str = '\u00bd + \u00bc = \u00be'; * * console.log(`${str}: ${str.length} characters, ` + * `${Buffer.byteLength(str, 'utf8')} bytes`); * // Prints: ½ + ¼ = ¾: 9 characters, 12 bytes * ``` * * When `string` is a * `Buffer`/[`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView)/[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/- * Reference/Global_Objects/TypedArray)/[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)/[`SharedArrayBuffer`](https://develop- * er.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer), the byte length as reported by `.byteLength`is returned. * @since v0.1.90 * @param string A value to calculate the length of. * @param [encoding='utf8'] If `string` is a string, this is its encoding. * @return The number of bytes contained within `string`. */ static byteLength( string: | string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: Encoding, ): number; /** * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together. * * If the list has no items, or if the `totalLength` is 0, then a new zero-length`Buffer` is returned. * * If `totalLength` is not provided, it is calculated from the `Buffer` instances * in `list` by adding their lengths. * * If `totalLength` is provided, it is coerced to an unsigned integer. If the * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is * truncated to `totalLength`. * * ```js * import { Buffer } from 'buffer'; * * // Create a single `Buffer` from a list of three `Buffer` instances. * * const buf1 = Buffer.alloc(10); * const buf2 = Buffer.alloc(14); * const buf3 = Buffer.alloc(18); * const totalLength = buf1.length + buf2.length + buf3.length; * * console.log(totalLength); * // Prints: 42 * * const bufA = Buffer.concat([buf1, buf2, buf3], totalLength); * * console.log(bufA); * // Prints: <Buffer 00 00 00 00 ...> * console.log(bufA.length); * // Prints: 42 * ``` * * `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does. * @since v0.7.11 * @param list List of `Buffer` or {@link Uint8Array} instances to concatenate. * @param totalLength Total length of the `Buffer` instances in `list` when concatenated. */ static concat( list: ReadonlyArray<Uint8Array>, totalLength?: number, ): Buffer; /** * Compares `buf1` to `buf2`, typically for the purpose of sorting arrays of`Buffer` instances. This is equivalent to calling `buf1.compare(buf2)`. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from('1234'); * const buf2 = Buffer.from('0123'); * const arr = [buf1, buf2]; * * console.log(arr.sort(Buffer.compare)); * // Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ] * // (This result is equal to: [buf2, buf1].) * ``` * @since v0.11.13 * @return Either `-1`, `0`, or `1`, depending on the result of the comparison. See `compare` for details. */ static compare(buf1: Uint8Array, buf2: Uint8Array): number; /** * Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.alloc(5); * * console.log(buf); * // Prints: <Buffer 00 00 00 00 00> * ``` * * If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. * * If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.alloc(5, 'a'); * * console.log(buf); * // Prints: <Buffer 61 61 61 61 61> * ``` * * If both `fill` and `encoding` are specified, the allocated `Buffer` will be * initialized by calling `buf.fill(fill, encoding)`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64'); * * console.log(buf); * // Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64> * ``` * * Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance * contents will never contain sensitive data from previous allocations, including * data that might not have been allocated for `Buffer`s. * * A `TypeError` will be thrown if `size` is not a number. * @since v5.10.0 * @param size The desired length of the new `Buffer`. * @param [fill=0] A value to pre-fill the new `Buffer` with. * @param [encoding='utf8'] If `fill` is a string, this is its encoding. */ static alloc( size: number, fill?: string | Uint8Array | number, encoding?: Encoding, ): Buffer; /** * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. * * The underlying memory for `Buffer` instances created in this way is _not_ * _initialized_. The contents of the newly created `Buffer` are unknown and_may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(10); * * console.log(buf); * // Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32> * * buf.fill(0); * * console.log(buf); * // Prints: <Buffer 00 00 00 00 00 00 00 00 00 00> * ``` * * A `TypeError` will be thrown if `size` is not a number. * * The `Buffer` module pre-allocates an internal `Buffer` instance of * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`,`Buffer.from(array)`, `Buffer.concat()`, and the * deprecated`new Buffer(size)` constructor only when `size` is less than or equal * to `Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two). * * Use of this pre-allocated internal memory pool is a key difference between * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`. * Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less * than or equal to half `Buffer.poolSize`. The * difference is subtle but can be important when an application requires the * additional performance that `Buffer.allocUnsafe()` provides. * @since v5.10.0 * @param size The desired length of the new `Buffer`. */ static allocUnsafe(size: number): Buffer; /** * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. A zero-length `Buffer` is created * if `size` is 0. * * The underlying memory for `Buffer` instances created in this way is _not_ * _initialized_. The contents of the newly created `Buffer` are unknown and_may contain sensitive data_. Use `buf.fill(0)` to initialize * such `Buffer` instances with zeroes. * * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances, * allocations under 4 KB are sliced from a single pre-allocated `Buffer`. This * allows applications to avoid the garbage collection overhead of creating many * individually allocated `Buffer` instances. This approach improves both * performance and memory usage by eliminating the need to track and clean up as * many individual `ArrayBuffer` objects. * * However, in the case where a developer may need to retain a small chunk of * memory from a pool for an indeterminate amount of time, it may be appropriate * to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and * then copying out the relevant bits. * * ```js * import { Buffer } from 'buffer'; * * // Need to keep around a few small chunks of memory. * const store = []; * * socket.on('readable', () => { * let data; * while (null !== (data = readable.read())) { * // Allocate for retained data. * const sb = Buffer.allocUnsafeSlow(10); * * // Copy the data into the new allocation. * data.copy(sb, 0, 0, 10); * * store.push(sb); * } * }); * ``` * * A `TypeError` will be thrown if `size` is not a number. * @since v5.12.0 * @param size The desired length of the new `Buffer`. */ static allocUnsafeSlow(size: number): Buffer; // /** // * This is the size (in bytes) of pre-allocated internal `Buffer` instances used // * for pooling. This value may be modified. // * @since v0.11.3 // */ // static poolSize: number;
/** * Writes `string` to `buf` at `offset` according to the character encoding in`encoding`. The `length` parameter is the number of bytes to write. If `buf` did * not contain enough space to fit the entire string, only part of `string` will be * written. However, partially encoded characters will not be written. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.alloc(256); * * const len = buf.write('\u00bd + \u00bc = \u00be', 0); * * console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`); * // Prints: 12 bytes: ½ + ¼ = ¾ * * const buffer = Buffer.alloc(10); * * const length = buffer.write('abcd', 8); * * console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`); * // Prints: 2 bytes : ab * ``` * @since v0.1.90 * @param string String to write to `buf`. * @param [offset=0] Number of bytes to skip before starting to write `string`. * @param [length=buf.length - offset] Maximum number of bytes to write (written bytes will not exceed `buf.length - offset`). * @param [encoding='utf8'] The character encoding of `string`. * @return Number of bytes written. */ write(string: string, encoding?: Encoding): number; write(string: string, offset: number, encoding?: Encoding): number; write( string: string, offset: number, length: number, encoding?: Encoding, ): number; /** * Decodes `buf` to a string according to the specified character encoding in`encoding`. `start` and `end` may be passed to decode only a subset of `buf`. * * If `encoding` is `'utf8'` and a byte sequence in the input is not valid UTF-8, * then each invalid byte is replaced with the replacement character `U+FFFD`. * * The maximum length of a string instance (in UTF-16 code units) is available * as {@link constants.MAX_STRING_LENGTH}. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.allocUnsafe(26); * * for (let i = 0; i < 26; i++) { * // 97 is the decimal ASCII value for 'a'. * buf1[i] = i + 97; * } * * console.log(buf1.toString('utf8')); * // Prints: abcdefghijklmnopqrstuvwxyz * console.log(buf1.toString('utf8', 0, 5)); * // Prints: abcde * * const buf2 = Buffer.from('tést'); * * console.log(buf2.toString('hex')); * // Prints: 74c3a97374 * console.log(buf2.toString('utf8', 0, 3)); * // Prints: té * console.log(buf2.toString(undefined, 0, 3)); * // Prints: té * ``` * @since v0.1.90 * @param [encoding='utf8'] The character encoding to use. * @param [start=0] The byte offset to start decoding at. * @param [end=buf.length] The byte offset to stop decoding at (not inclusive). */ toString(encoding?: Encoding, start?: number, end?: number): string; /** * Returns a JSON representation of `buf`. [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) implicitly calls * this function when stringifying a `Buffer` instance. * * `Buffer.from()` accepts objects in the format returned from this method. * In particular, `Buffer.from(buf.toJSON())` works like `Buffer.from(buf)`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]); * const json = JSON.stringify(buf); * * console.log(json); * // Prints: {"type":"Buffer","data":[1,2,3,4,5]} * * const copy = JSON.parse(json, (key, value) => { * return value && value.type === 'Buffer' ? * Buffer.from(value) : * value; * }); * * console.log(copy); * // Prints: <Buffer 01 02 03 04 05> * ``` * @since v0.9.2 */ toJSON(): { type: "Buffer"; data: number[]; }; /** * Returns `true` if both `buf` and `otherBuffer` have exactly the same bytes,`false` otherwise. Equivalent to `buf.compare(otherBuffer) === 0`. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from('ABC'); * const buf2 = Buffer.from('414243', 'hex'); * const buf3 = Buffer.from('ABCD'); * * console.log(buf1.equals(buf2)); * // Prints: true * console.log(buf1.equals(buf3)); * // Prints: false * ``` * @since v0.11.13 * @param otherBuffer A `Buffer` or {@link Uint8Array} with which to compare `buf`. */ equals(otherBuffer: Uint8Array): boolean; /** * Compares `buf` with `target` and returns a number indicating whether `buf`comes before, after, or is the same as `target` in sort order. * Comparison is based on the actual sequence of bytes in each `Buffer`. * * * `0` is returned if `target` is the same as `buf` * * `1` is returned if `target` should come _before_`buf` when sorted. * * `-1` is returned if `target` should come _after_`buf` when sorted. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from('ABC'); * const buf2 = Buffer.from('BCD'); * const buf3 = Buffer.from('ABCD'); * * console.log(buf1.compare(buf1)); * // Prints: 0 * console.log(buf1.compare(buf2)); * // Prints: -1 * console.log(buf1.compare(buf3)); * // Prints: -1 * console.log(buf2.compare(buf1)); * // Prints: 1 * console.log(buf2.compare(buf3)); * // Prints: 1 * console.log([buf1, buf2, buf3].sort(Buffer.compare)); * // Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ] * // (This result is equal to: [buf1, buf3, buf2].) * ``` * * The optional `targetStart`, `targetEnd`, `sourceStart`, and `sourceEnd`arguments can be used to limit the comparison to specific ranges within `target`and `buf` respectively. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]); * const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]); * * console.log(buf1.compare(buf2, 5, 9, 0, 4)); * // Prints: 0 * console.log(buf1.compare(buf2, 0, 6, 4)); * // Prints: -1 * console.log(buf1.compare(buf2, 5, 6, 5)); * // Prints: 1 * ``` * * `ERR_OUT_OF_RANGE` is thrown if `targetStart < 0`, `sourceStart < 0`,`targetEnd > target.byteLength`, or `sourceEnd > source.byteLength`. * @since v0.11.13 * @param target A `Buffer` or {@link Uint8Array} with which to compare `buf`. * @param [targetStart=0] The offset within `target` at which to begin comparison. * @param [targetEnd=target.length] The offset within `target` at which to end comparison (not inclusive). * @param [sourceStart=0] The offset within `buf` at which to begin comparison. * @param [sourceEnd=buf.length] The offset within `buf` at which to end comparison (not inclusive). */ compare( target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number, ): number; /** * Copies data from a region of `buf` to a region in `target`, even if the `target`memory region overlaps with `buf`. * * [`TypedArray.prototype.set()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) performs the same operation, and is available * for all TypedArrays, including Node.js `Buffer`s, although it takes * different function arguments. * * ```js * import { Buffer } from 'buffer'; * * // Create two `Buffer` instances. * const buf1 = Buffer.allocUnsafe(26); * const buf2 = Buffer.allocUnsafe(26).fill('!'); * * for (let i = 0; i < 26; i++) { * // 97 is the decimal ASCII value for 'a'. * buf1[i] = i + 97; * } * * // Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`. * buf1.copy(buf2, 8, 16, 20); * // This is equivalent to: * // buf2.set(buf1.subarray(16, 20), 8); * * console.log(buf2.toString('ascii', 0, 25)); * // Prints: !!!!!!!!qrst!!!!!!!!!!!!! * ``` * * ```js * import { Buffer } from 'buffer'; * * // Create a `Buffer` and copy data from one region to an overlapping region * // within the same `Buffer`. * * const buf = Buffer.allocUnsafe(26); * * for (let i = 0; i < 26; i++) { * // 97 is the decimal ASCII value for 'a'. * buf[i] = i + 97; * } * * buf.copy(buf, 0, 4, 10); * * console.log(buf.toString()); * // Prints: efghijghijklmnopqrstuvwxyz * ``` * @since v0.1.90 * @param target A `Buffer` or {@link Uint8Array} to copy into. * @param [targetStart=0] The offset within `target` at which to begin writing. * @param [sourceStart=0] The offset within `buf` from which to begin copying. * @param [sourceEnd=buf.length] The offset within `buf` at which to stop copying (not inclusive). * @return The number of bytes copied. */ copy( target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number, ): number; /** * Returns a new `Buffer` that references the same memory as the original, but * offset and cropped by the `start` and `end` indices. * * This is the same behavior as `buf.subarray()`. * * This method is not compatible with the `Uint8Array.prototype.slice()`, * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('buffer'); * * const copiedBuf = Uint8Array.prototype.slice.call(buf); * copiedBuf[0]++; * console.log(copiedBuf.toString()); * // Prints: cuffer * * console.log(buf.toString()); * // Prints: buffer * ``` * @since v0.3.0 * @param [start=0] Where the new `Buffer` will start. * @param [end=buf.length] Where the new `Buffer` will end (not inclusive). */ slice(start?: number, end?: number): Buffer; /** * Returns a new `Buffer` that references the same memory as the original, but * offset and cropped by the `start` and `end` indices. * * Specifying `end` greater than `buf.length` will return the same result as * that of `end` equal to `buf.length`. * * This method is inherited from [`TypedArray.prototype.subarray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray). * * Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap. * * ```js * import { Buffer } from 'buffer'; * * // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte * // from the original `Buffer`. * * const buf1 = Buffer.allocUnsafe(26); * * for (let i = 0; i < 26; i++) { * // 97 is the decimal ASCII value for 'a'. * buf1[i] = i + 97; * } * * const buf2 = buf1.subarray(0, 3); * * console.log(buf2.toString('ascii', 0, buf2.length)); * // Prints: abc * * buf1[0] = 33; * * console.log(buf2.toString('ascii', 0, buf2.length)); * // Prints: !bc * ``` * * Specifying negative indexes causes the slice to be generated relative to the * end of `buf` rather than the beginning. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('buffer'); * * console.log(buf.subarray(-6, -1).toString()); * // Prints: buffe * // (Equivalent to buf.subarray(0, 5).) * * console.log(buf.subarray(-6, -2).toString()); * // Prints: buff * // (Equivalent to buf.subarray(0, 4).) * * console.log(buf.subarray(-5, -2).toString()); * // Prints: uff * // (Equivalent to buf.subarray(1, 4).) * ``` * @since v3.0.0 * @param [start=0] Where the new `Buffer` will start. * @param [end=buf.length] Where the new `Buffer` will end (not inclusive). */ subarray(start?: number, end?: number): Buffer; /** * Writes `value` to `buf` at the specified `offset` as big-endian. * * `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(8); * * buf.writeBigInt64BE(0x0102030405060708n, 0); * * console.log(buf); * // Prints: <Buffer 01 02 03 04 05 06 07 08> * ``` * @since v12.0.0, v10.20.0 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. * @return `offset` plus the number of bytes written. */ writeBigInt64BE(value: bigint, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. * * `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(8); * * buf.writeBigInt64LE(0x0102030405060708n, 0); * * console.log(buf); * // Prints: <Buffer 08 07 06 05 04 03 02 01> * ``` * @since v12.0.0, v10.20.0 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. * @return `offset` plus the number of bytes written. */ writeBigInt64LE(value: bigint, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. * * This function is also available under the `writeBigUint64BE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(8); * * buf.writeBigUInt64BE(0xdecafafecacefaden, 0); * * console.log(buf); * // Prints: <Buffer de ca fa fe ca ce fa de> * ``` * @since v12.0.0, v10.20.0 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. * @return `offset` plus the number of bytes written. */ writeBigUInt64BE(value: bigint, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(8); * * buf.writeBigUInt64LE(0xdecafafecacefaden, 0); * * console.log(buf); * // Prints: <Buffer de fa ce ca fe fa ca de> * ``` * * This function is also available under the `writeBigUint64LE` alias. * @since v12.0.0, v10.20.0 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy: `0 <= offset <= buf.length - 8`. * @return `offset` plus the number of bytes written. */ writeBigUInt64LE(value: bigint, offset?: number): number; /** * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined * when `value` is anything other than an unsigned integer. * * This function is also available under the `writeUintLE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(6); * * buf.writeUIntLE(0x1234567890ab, 0, 6); * * console.log(buf); * // Prints: <Buffer ab 90 78 56 34 12> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. * @return `offset` plus the number of bytes written. */ writeUIntLE(value: number, offset: number, byteLength: number): number; /** * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined * when `value` is anything other than an unsigned integer. * * This function is also available under the `writeUintBE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(6); * * buf.writeUIntBE(0x1234567890ab, 0, 6); * * console.log(buf); * // Prints: <Buffer 12 34 56 78 90 ab> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. * @return `offset` plus the number of bytes written. */ writeUIntBE(value: number, offset: number, byteLength: number): number; /** * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined * when `value` is anything other than a signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(6); * * buf.writeIntLE(0x1234567890ab, 0, 6); * * console.log(buf); * // Prints: <Buffer ab 90 78 56 34 12> * ``` * @since v0.11.15 * @param value Number to be written to `buf`. * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. * @return `offset` plus the number of bytes written. */ writeIntLE(value: number, offset: number, byteLength: number): number; /** * Writes `byteLength` bytes of `value` to `buf` at the specified `offset`as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when`value` is anything other than a * signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(6); * * buf.writeIntBE(0x1234567890ab, 0, 6); * * console.log(buf); * // Prints: <Buffer 12 34 56 78 90 ab> * ``` * @since v0.11.15 * @param value Number to be written to `buf`. * @param offset Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to write. Must satisfy `0 < byteLength <= 6`. * @return `offset` plus the number of bytes written. */ writeIntBE(value: number, offset: number, byteLength: number): number; /** * Reads an unsigned, big-endian 64-bit integer from `buf` at the specified`offset`. * * This function is also available under the `readBigUint64BE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]); * * console.log(buf.readBigUInt64BE(0)); * // Prints: 4294967295n * ``` * @since v12.0.0, v10.20.0 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. */ readBigUInt64BE(offset?: number): bigint; /** * Reads an unsigned, little-endian 64-bit integer from `buf` at the specified`offset`. * * This function is also available under the `readBigUint64LE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]); * * console.log(buf.readBigUInt64LE(0)); * // Prints: 18446744069414584320n * ``` * @since v12.0.0, v10.20.0 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. */ readBigUInt64LE(offset?: number): bigint; /** * Reads a signed, big-endian 64-bit integer from `buf` at the specified `offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed * values. * @since v12.0.0, v10.20.0 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. */ readBigInt64BE(offset?: number): bigint; /** * Reads a signed, little-endian 64-bit integer from `buf` at the specified`offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed * values. * @since v12.0.0, v10.20.0 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy: `0 <= offset <= buf.length - 8`. */ readBigInt64LE(offset?: number): bigint; /** * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as an unsigned, little-endian integer supporting * up to 48 bits of accuracy. * * This function is also available under the `readUintLE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); * * console.log(buf.readUIntLE(0, 6).toString(16)); * // Prints: ab9078563412 * ``` * @since v0.11.15 * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. */ readUIntLE(offset: number, byteLength: number): number; /** * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as an unsigned big-endian integer supporting * up to 48 bits of accuracy. * * This function is also available under the `readUintBE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); * * console.log(buf.readUIntBE(0, 6).toString(16)); * // Prints: 1234567890ab * console.log(buf.readUIntBE(1, 6).toString(16)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.11.15 * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. */ readUIntBE(offset: number, byteLength: number): number; /** * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as a little-endian, two's complement signed value * supporting up to 48 bits of accuracy. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); * * console.log(buf.readIntLE(0, 6).toString(16)); * // Prints: -546f87a9cbee * ``` * @since v0.11.15 * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. */ readIntLE(offset: number, byteLength: number): number; /** * Reads `byteLength` number of bytes from `buf` at the specified `offset`and interprets the result as a big-endian, two's complement signed value * supporting up to 48 bits of accuracy. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]); * * console.log(buf.readIntBE(0, 6).toString(16)); * // Prints: 1234567890ab * console.log(buf.readIntBE(1, 6).toString(16)); * // Throws ERR_OUT_OF_RANGE. * console.log(buf.readIntBE(1, 0).toString(16)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.11.15 * @param offset Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - byteLength`. * @param byteLength Number of bytes to read. Must satisfy `0 < byteLength <= 6`. */ readIntBE(offset: number, byteLength: number): number; /** * Reads an unsigned 8-bit integer from `buf` at the specified `offset`. * * This function is also available under the `readUint8` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([1, -2]); * * console.log(buf.readUInt8(0)); * // Prints: 1 * console.log(buf.readUInt8(1)); * // Prints: 254 * console.log(buf.readUInt8(2)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.5.0 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 1`. */ readUInt8(offset?: number): number; /** * Reads an unsigned, little-endian 16-bit integer from `buf` at the specified`offset`. * * This function is also available under the `readUint16LE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56]); * * console.log(buf.readUInt16LE(0).toString(16)); * // Prints: 3412 * console.log(buf.readUInt16LE(1).toString(16)); * // Prints: 5634 * console.log(buf.readUInt16LE(2).toString(16)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. */ readUInt16LE(offset?: number): number; /** * Reads an unsigned, big-endian 16-bit integer from `buf` at the specified`offset`. * * This function is also available under the `readUint16BE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56]); * * console.log(buf.readUInt16BE(0).toString(16)); * // Prints: 1234 * console.log(buf.readUInt16BE(1).toString(16)); * // Prints: 3456 * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. */ readUInt16BE(offset?: number): number; /** * Reads an unsigned, little-endian 32-bit integer from `buf` at the specified`offset`. * * This function is also available under the `readUint32LE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]); * * console.log(buf.readUInt32LE(0).toString(16)); * // Prints: 78563412 * console.log(buf.readUInt32LE(1).toString(16)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. */ readUInt32LE(offset?: number): number; /** * Reads an unsigned, big-endian 32-bit integer from `buf` at the specified`offset`. * * This function is also available under the `readUint32BE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]); * * console.log(buf.readUInt32BE(0).toString(16)); * // Prints: 12345678 * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. */ readUInt32BE(offset?: number): number; /** * Reads a signed 8-bit integer from `buf` at the specified `offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed values. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([-1, 5]); * * console.log(buf.readInt8(0)); * // Prints: -1 * console.log(buf.readInt8(1)); * // Prints: 5 * console.log(buf.readInt8(2)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.5.0 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 1`. */ readInt8(offset?: number): number; /** * Reads a signed, little-endian 16-bit integer from `buf` at the specified`offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed values. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0, 5]); * * console.log(buf.readInt16LE(0)); * // Prints: 1280 * console.log(buf.readInt16LE(1)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. */ readInt16LE(offset?: number): number; /** * Reads a signed, big-endian 16-bit integer from `buf` at the specified `offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed values. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0, 5]); * * console.log(buf.readInt16BE(0)); * // Prints: 5 * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 2`. */ readInt16BE(offset?: number): number; /** * Reads a signed, little-endian 32-bit integer from `buf` at the specified`offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed values. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0, 0, 0, 5]); * * console.log(buf.readInt32LE(0)); * // Prints: 83886080 * console.log(buf.readInt32LE(1)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. */ readInt32LE(offset?: number): number; /** * Reads a signed, big-endian 32-bit integer from `buf` at the specified `offset`. * * Integers read from a `Buffer` are interpreted as two's complement signed values. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([0, 0, 0, 5]); * * console.log(buf.readInt32BE(0)); * // Prints: 5 * ``` * @since v0.5.5 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. */ readInt32BE(offset?: number): number; /** * Reads a 32-bit, little-endian float from `buf` at the specified `offset`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([1, 2, 3, 4]); * * console.log(buf.readFloatLE(0)); * // Prints: 1.539989614439558e-36 * console.log(buf.readFloatLE(1)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.11.15 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. */ readFloatLE(offset?: number): number; /** * Reads a 32-bit, big-endian float from `buf` at the specified `offset`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([1, 2, 3, 4]); * * console.log(buf.readFloatBE(0)); * // Prints: 2.387939260590663e-38 * ``` * @since v0.11.15 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 4`. */ readFloatBE(offset?: number): number; /** * Reads a 64-bit, little-endian double from `buf` at the specified `offset`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); * * console.log(buf.readDoubleLE(0)); * // Prints: 5.447603722011605e-270 * console.log(buf.readDoubleLE(1)); * // Throws ERR_OUT_OF_RANGE. * ``` * @since v0.11.15 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 8`. */ readDoubleLE(offset?: number): number; /** * Reads a 64-bit, big-endian double from `buf` at the specified `offset`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]); * * console.log(buf.readDoubleBE(0)); * // Prints: 8.20788039913184e-304 * ``` * @since v0.11.15 * @param [offset=0] Number of bytes to skip before starting to read. Must satisfy `0 <= offset <= buf.length - 8`. */ readDoubleBE(offset?: number): number; reverse(): this; /** * Interprets `buf` as an array of unsigned 16-bit integers and swaps the * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 2. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); * * console.log(buf1); * // Prints: <Buffer 01 02 03 04 05 06 07 08> * * buf1.swap16(); * * console.log(buf1); * // Prints: <Buffer 02 01 04 03 06 05 08 07> * * const buf2 = Buffer.from([0x1, 0x2, 0x3]); * * buf2.swap16(); * // Throws ERR_INVALID_BUFFER_SIZE. * ``` * * One convenient use of `buf.swap16()` is to perform a fast in-place conversion * between UTF-16 little-endian and UTF-16 big-endian: * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('This is little-endian UTF-16', 'utf16le'); * buf.swap16(); // Convert to big-endian UTF-16 text. * ``` * @since v5.10.0 * @return A reference to `buf`. */ swap16(): Buffer; /** * Interprets `buf` as an array of unsigned 32-bit integers and swaps the * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 4. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); * * console.log(buf1); * // Prints: <Buffer 01 02 03 04 05 06 07 08> * * buf1.swap32(); * * console.log(buf1); * // Prints: <Buffer 04 03 02 01 08 07 06 05> * * const buf2 = Buffer.from([0x1, 0x2, 0x3]); * * buf2.swap32(); * // Throws ERR_INVALID_BUFFER_SIZE. * ``` * @since v5.10.0 * @return A reference to `buf`. */ swap32(): Buffer; /** * Interprets `buf` as an array of 64-bit numbers and swaps byte order _in-place_. * Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 8. * * ```js * import { Buffer } from 'buffer'; * * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); * * console.log(buf1); * // Prints: <Buffer 01 02 03 04 05 06 07 08> * * buf1.swap64(); * * console.log(buf1); * // Prints: <Buffer 08 07 06 05 04 03 02 01> * * const buf2 = Buffer.from([0x1, 0x2, 0x3]); * * buf2.swap64(); * // Throws ERR_INVALID_BUFFER_SIZE. * ``` * @since v6.3.0 * @return A reference to `buf`. */ swap64(): Buffer; /** * Writes `value` to `buf` at the specified `offset`. `value` must be a * valid unsigned 8-bit integer. Behavior is undefined when `value` is anything * other than an unsigned 8-bit integer. * * This function is also available under the `writeUint8` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeUInt8(0x3, 0); * buf.writeUInt8(0x4, 1); * buf.writeUInt8(0x23, 2); * buf.writeUInt8(0x42, 3); * * console.log(buf); * // Prints: <Buffer 03 04 23 42> * ``` * @since v0.5.0 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 1`. * @return `offset` plus the number of bytes written. */ writeUInt8(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid unsigned 16-bit integer. Behavior is undefined when `value` is * anything other than an unsigned 16-bit integer. * * This function is also available under the `writeUint16LE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeUInt16LE(0xdead, 0); * buf.writeUInt16LE(0xbeef, 2); * * console.log(buf); * // Prints: <Buffer ad de ef be> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. * @return `offset` plus the number of bytes written. */ writeUInt16LE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid unsigned 16-bit integer. Behavior is undefined when `value`is anything other than an * unsigned 16-bit integer. * * This function is also available under the `writeUint16BE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeUInt16BE(0xdead, 0); * buf.writeUInt16BE(0xbeef, 2); * * console.log(buf); * // Prints: <Buffer de ad be ef> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. * @return `offset` plus the number of bytes written. */ writeUInt16BE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid unsigned 32-bit integer. Behavior is undefined when `value` is * anything other than an unsigned 32-bit integer. * * This function is also available under the `writeUint32LE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeUInt32LE(0xfeedface, 0); * * console.log(buf); * // Prints: <Buffer ce fa ed fe> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. * @return `offset` plus the number of bytes written. */ writeUInt32LE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid unsigned 32-bit integer. Behavior is undefined when `value`is anything other than an * unsigned 32-bit integer. * * This function is also available under the `writeUint32BE` alias. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeUInt32BE(0xfeedface, 0); * * console.log(buf); * // Prints: <Buffer fe ed fa ce> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. * @return `offset` plus the number of bytes written. */ writeUInt32BE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset`. `value` must be a valid * signed 8-bit integer. Behavior is undefined when `value` is anything other than * a signed 8-bit integer. * * `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(2); * * buf.writeInt8(2, 0); * buf.writeInt8(-2, 1); * * console.log(buf); * // Prints: <Buffer 02 fe> * ``` * @since v0.5.0 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 1`. * @return `offset` plus the number of bytes written. */ writeInt8(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid signed 16-bit integer. Behavior is undefined when `value` is * anything other than a signed 16-bit integer. * * The `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(2); * * buf.writeInt16LE(0x0304, 0); * * console.log(buf); * // Prints: <Buffer 04 03> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. * @return `offset` plus the number of bytes written. */ writeInt16LE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid signed 16-bit integer. Behavior is undefined when `value` is * anything other than a signed 16-bit integer. * * The `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(2); * * buf.writeInt16BE(0x0102, 0); * * console.log(buf); * // Prints: <Buffer 01 02> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 2`. * @return `offset` plus the number of bytes written. */ writeInt16BE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a valid signed 32-bit integer. Behavior is undefined when `value` is * anything other than a signed 32-bit integer. * * The `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeInt32LE(0x05060708, 0); * * console.log(buf); * // Prints: <Buffer 08 07 06 05> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. * @return `offset` plus the number of bytes written. */ writeInt32LE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a valid signed 32-bit integer. Behavior is undefined when `value` is * anything other than a signed 32-bit integer. * * The `value` is interpreted and written as a two's complement signed integer. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeInt32BE(0x01020304, 0); * * console.log(buf); * // Prints: <Buffer 01 02 03 04> * ``` * @since v0.5.5 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. * @return `offset` plus the number of bytes written. */ writeInt32BE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. Behavior is * undefined when `value` is anything other than a JavaScript number. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeFloatLE(0xcafebabe, 0); * * console.log(buf); * // Prints: <Buffer bb fe 4a 4f> * ``` * @since v0.11.15 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. * @return `offset` plus the number of bytes written. */ writeFloatLE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. Behavior is * undefined when `value` is anything other than a JavaScript number. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(4); * * buf.writeFloatBE(0xcafebabe, 0); * * console.log(buf); * // Prints: <Buffer 4f 4a fe bb> * ``` * @since v0.11.15 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 4`. * @return `offset` plus the number of bytes written. */ writeFloatBE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as little-endian. The `value`must be a JavaScript number. Behavior is undefined when `value` is anything * other than a JavaScript number. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(8); * * buf.writeDoubleLE(123.456, 0); * * console.log(buf); * // Prints: <Buffer 77 be 9f 1a 2f dd 5e 40> * ``` * @since v0.11.15 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 8`. * @return `offset` plus the number of bytes written. */ writeDoubleLE(value: number, offset?: number): number; /** * Writes `value` to `buf` at the specified `offset` as big-endian. The `value`must be a JavaScript number. Behavior is undefined when `value` is anything * other than a JavaScript number. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(8); * * buf.writeDoubleBE(123.456, 0); * * console.log(buf); * // Prints: <Buffer 40 5e dd 2f 1a 9f be 77> * ``` * @since v0.11.15 * @param value Number to be written to `buf`. * @param [offset=0] Number of bytes to skip before starting to write. Must satisfy `0 <= offset <= buf.length - 8`. * @return `offset` plus the number of bytes written. */ writeDoubleBE(value: number, offset?: number): number; /** * Fills `buf` with the specified `value`. If the `offset` and `end` are not given, * the entire `buf` will be filled: * * ```js * import { Buffer } from 'buffer'; * * // Fill a `Buffer` with the ASCII character 'h'. * * const b = Buffer.allocUnsafe(50).fill('h'); * * console.log(b.toString()); * // Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh * ``` * * `value` is coerced to a `uint32` value if it is not a string, `Buffer`, or * integer. If the resulting integer is greater than `255` (decimal), `buf` will be * filled with `value & 255`. * * If the final write of a `fill()` operation falls on a multi-byte character, * then only the bytes of that character that fit into `buf` are written: * * ```js * import { Buffer } from 'buffer'; * * // Fill a `Buffer` with character that takes up two bytes in UTF-8. * * console.log(Buffer.allocUnsafe(5).fill('\u0222')); * // Prints: <Buffer c8 a2 c8 a2 c8> * ``` * * If `value` contains invalid characters, it is truncated; if no valid * fill data remains, an exception is thrown: * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.allocUnsafe(5); * * console.log(buf.fill('a')); * // Prints: <Buffer 61 61 61 61 61> * console.log(buf.fill('aazz', 'hex')); * // Prints: <Buffer aa aa aa aa aa> * console.log(buf.fill('zz', 'hex')); * // Throws an exception. * ``` * @since v0.5.0 * @param value The value with which to fill `buf`. * @param [offset=0] Number of bytes to skip before starting to fill `buf`. * @param [end=buf.length] Where to stop filling `buf` (not inclusive). * @param [encoding='utf8'] The encoding for `value` if `value` is a string. * @return A reference to `buf`. */ fill( value: string | Uint8Array | number, offset?: number, end?: number, encoding?: Encoding, ): this; /** * If `value` is: * * * a string, `value` is interpreted according to the character encoding in`encoding`. * * a `Buffer` or [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), `value` will be used in its entirety. * To compare a partial `Buffer`, use `buf.slice()`. * * a number, `value` will be interpreted as an unsigned 8-bit integer * value between `0` and `255`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('this is a buffer'); * * console.log(buf.indexOf('this')); * // Prints: 0 * console.log(buf.indexOf('is')); * // Prints: 2 * console.log(buf.indexOf(Buffer.from('a buffer'))); * // Prints: 8 * console.log(buf.indexOf(97)); * // Prints: 8 (97 is the decimal ASCII value for 'a') * console.log(buf.indexOf(Buffer.from('a buffer example'))); * // Prints: -1 * console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8))); * // Prints: 8 * * const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le'); * * console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le')); * // Prints: 4 * console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le')); * // Prints: 6 * ``` * * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value, * an integer between 0 and 255. * * If `byteOffset` is not a number, it will be coerced to a number. If the result * of coercion is `NaN` or `0`, then the entire buffer will be searched. This * behavior matches [`String.prototype.indexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf). * * ```js * import { Buffer } from 'buffer'; * * const b = Buffer.from('abcdef'); * * // Passing a value that's a number, but not a valid byte. * // Prints: 2, equivalent to searching for 99 or 'c'. * console.log(b.indexOf(99.9)); * console.log(b.indexOf(256 + 99)); * * // Passing a byteOffset that coerces to NaN or 0. * // Prints: 1, searching the whole buffer. * console.log(b.indexOf('b', undefined)); * console.log(b.indexOf('b', {})); * console.log(b.indexOf('b', null)); * console.log(b.indexOf('b', [])); * ``` * * If `value` is an empty string or empty `Buffer` and `byteOffset` is less * than `buf.length`, `byteOffset` will be returned. If `value` is empty and`byteOffset` is at least `buf.length`, `buf.length` will be returned. * @since v1.5.0 * @param value What to search for. * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`. * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`. * @return The index of the first occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`. */ indexOf( value: string | number | Uint8Array, byteOffset?: number, encoding?: Encoding, ): number; /** * Identical to `buf.indexOf()`, except the last occurrence of `value` is found * rather than the first occurrence. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('this buffer is a buffer'); * * console.log(buf.lastIndexOf('this')); * // Prints: 0 * console.log(buf.lastIndexOf('buffer')); * // Prints: 17 * console.log(buf.lastIndexOf(Buffer.from('buffer'))); * // Prints: 17 * console.log(buf.lastIndexOf(97)); * // Prints: 15 (97 is the decimal ASCII value for 'a') * console.log(buf.lastIndexOf(Buffer.from('yolo'))); * // Prints: -1 * console.log(buf.lastIndexOf('buffer', 5)); * // Prints: 5 * console.log(buf.lastIndexOf('buffer', 4)); * // Prints: -1 * * const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le'); * * console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le')); * // Prints: 6 * console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le')); * // Prints: 4 * ``` * * If `value` is not a string, number, or `Buffer`, this method will throw a`TypeError`. If `value` is a number, it will be coerced to a valid byte value, * an integer between 0 and 255. * * If `byteOffset` is not a number, it will be coerced to a number. Any arguments * that coerce to `NaN`, like `{}` or `undefined`, will search the whole buffer. * This behavior matches [`String.prototype.lastIndexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf). * * ```js * import { Buffer } from 'buffer'; * * const b = Buffer.from('abcdef'); * * // Passing a value that's a number, but not a valid byte. * // Prints: 2, equivalent to searching for 99 or 'c'. * console.log(b.lastIndexOf(99.9)); * console.log(b.lastIndexOf(256 + 99)); * * // Passing a byteOffset that coerces to NaN. * // Prints: 1, searching the whole buffer. * console.log(b.lastIndexOf('b', undefined)); * console.log(b.lastIndexOf('b', {})); * * // Passing a byteOffset that coerces to 0. * // Prints: -1, equivalent to passing 0. * console.log(b.lastIndexOf('b', null)); * console.log(b.lastIndexOf('b', [])); * ``` * * If `value` is an empty string or empty `Buffer`, `byteOffset` will be returned. * @since v6.0.0 * @param value What to search for. * @param [byteOffset=buf.length - 1] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`. * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`. * @return The index of the last occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`. */ lastIndexOf( value: string | number | Uint8Array, byteOffset?: number, encoding?: Encoding, ): number; /** * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `[index, byte]` pairs from the contents * of `buf`. * * ```js * import { Buffer } from 'buffer'; * * // Log the entire contents of a `Buffer`. * * const buf = Buffer.from('buffer'); * * for (const pair of buf.entries()) { * console.log(pair); * } * // Prints: * // [0, 98] * // [1, 117] * // [2, 102] * // [3, 102] * // [4, 101] * // [5, 114] * ``` * @since v1.1.0 */ entries(): IterableIterator<[number, number]>; /** * Equivalent to `buf.indexOf() !== -1`. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('this is a buffer'); * * console.log(buf.includes('this')); * // Prints: true * console.log(buf.includes('is')); * // Prints: true * console.log(buf.includes(Buffer.from('a buffer'))); * // Prints: true * console.log(buf.includes(97)); * // Prints: true (97 is the decimal ASCII value for 'a') * console.log(buf.includes(Buffer.from('a buffer example'))); * // Prints: false * console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8))); * // Prints: true * console.log(buf.includes('this', 4)); * // Prints: false * ``` * @since v5.3.0 * @param value What to search for. * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`. * @param [encoding='utf8'] If `value` is a string, this is its encoding. * @return `true` if `value` was found in `buf`, `false` otherwise. */ includes( value: string | number | Buffer, byteOffset?: number, encoding?: Encoding, ): boolean; /** * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `buf` keys (indices). * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('buffer'); * * for (const key of buf.keys()) { * console.log(key); * } * // Prints: * // 0 * // 1 * // 2 * // 3 * // 4 * // 5 * ``` * @since v1.1.0 */ keys(): IterableIterator<number>; /** * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) for `buf` values (bytes). This function is * called automatically when a `Buffer` is used in a `for..of` statement. * * ```js * import { Buffer } from 'buffer'; * * const buf = Buffer.from('buffer'); * * for (const value of buf.values()) { * console.log(value); * } * // Prints: * // 98 * // 117 * // 102 * // 102 * // 101 * // 114 * * for (const value of buf) { * console.log(value); * } * // Prints: * // 98 * // 117 * // 102 * // 102 * // 101 * // 114 * ``` * @since v1.1.0 */ values(): IterableIterator<number>;}
export const SlowBuffer: { /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */ new (size: number): Buffer; prototype: Buffer;};
export const atob: typeof globalThis.atob;export const Blob: Blob;export const btoa: typeof globalThis.btoa;export const constants: { MAX_LENGTH: number; MAX_STRING_LENGTH: number;};export const kMaxLength: number;export const kStringMaxLength: number;
declare const exports: { atob: typeof atob; Blob: Blob; btoa: typeof btoa; Buffer: Buffer; constants: typeof constants; kMaxLength: typeof kMaxLength; kStringMaxLength: typeof kStringMaxLength; SlowBuffer: typeof SlowBuffer;};
export default exports;
std
Version Info
a year ago
