2023-02-14 11:38:45 -05:00
// Copyright 2018-2023 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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 & # x26 ; & # x26 ; 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* const buf = Buffer . allocUnsafe ( 8 ) ;
*
* buf . writeBigInt64BE ( 0x0102030405060708 n , 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* const buf = Buffer . allocUnsafe ( 8 ) ;
*
* buf . writeBigInt64LE ( 0x0102030405060708 n , 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* const buf = Buffer . allocUnsafe ( 8 ) ;
*
* buf . writeBigUInt64BE ( 0xdecafafecacefade n , 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* const buf = Buffer . allocUnsafe ( 8 ) ;
*
* buf . writeBigUInt64LE ( 0xdecafafecacefade n , 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* // 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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
refactor(core): include_js_files! 'dir' option doesn't change specifiers (#18019)
This commit changes "include_js_files!" macro from "deno_core"
in a way that "dir" option doesn't cause specifiers to be rewritten
to include it.
Example:
```
include_js_files! {
dir "js",
"hello.js",
}
```
The above definition required embedders to use:
`import ... from "internal:<ext_name>/js/hello.js"`.
But with this change, the "js" directory in which the files are stored
is an implementation detail, which for embedders results in:
`import ... from "internal:<ext_name>/hello.js"`.
The directory the files are stored in, is an implementation detail and
in some cases might result in a significant size difference for the
snapshot. As an example, in "deno_node" extension, we store the
source code in "polyfills" directory; which resulted in each specifier
to look like "internal:deno_node/polyfills/<module_name>", but with
this change it's "internal:deno_node/<module_name>".
Given that "deno_node" has over 100 files, many of them having
several import specifiers to the same extension, this change removes
10 characters from each import specifier.
2023-03-04 21:31:38 -05:00
* import { Buffer } from "internal:deno_node/internal/buffer" ;
2023-02-14 11:38:45 -05:00
*
* 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 ;