From 4ea4bd52a534c3099eeb68116985f90d62993422 Mon Sep 17 00:00:00 2001 From: rahul007-bit Date: Tue, 26 Dec 2023 18:22:25 +0530 Subject: [PATCH] Add JSONnet support and update dependencies --- JS/wasm/assets/wasmjs/wit/http-types.wit | 6 +- JS/wasm/assets/wasmjs/wit/http.wit | 2 + JS/wasm/crates/wasmjs-engine/Cargo.lock | 26 +- .../crates/wasmjs-engine/package-lock.json | 8 +- JS/wasm/crates/wasmjs-engine/shims/build.js | 95 +- .../crates/wasmjs-engine/shims/package.json | 2 +- .../wasmjs-engine/shims/src/arakoo-jsonnet.js | 5 + .../crates/wasmjs-engine/shims/src/buffer.js | 13 +- .../crates/wasmjs-engine/shims/src/crypto.ts | 370 +- .../crates/wasmjs-engine/shims/src/events.ts | 4 +- .../crates/wasmjs-engine/shims/src/index.js | 154 +- .../shims/src/internal/async_hooks.d.ts | 24 +- .../shims/src/internal/async_hooks.ts | 8 +- .../shims/src/internal/buffer.d.ts | 48 +- .../shims/src/internal/buffer.ts | 850 ++--- .../shims/src/internal/constants.ts | 3 +- .../shims/src/internal/crypto.d.ts | 70 +- .../shims/src/internal/crypto.ts | 142 +- .../shims/src/internal/crypto_dh.ts | 292 +- .../shims/src/internal/crypto_hash.ts | 349 +- .../shims/src/internal/crypto_hkdf.ts | 202 +- .../shims/src/internal/crypto_keys.ts | 474 ++- .../shims/src/internal/crypto_pbkdf2.ts | 115 +- .../shims/src/internal/crypto_random.ts | 665 ++-- .../shims/src/internal/crypto_util.ts | 140 +- .../shims/src/internal/events.ts | 1382 ++++---- .../shims/src/internal/internal_buffer.ts | 1235 +++---- .../shims/src/internal/internal_errors.ts | 63 +- .../shims/src/internal/internal_inspect.ts | 1396 +++----- .../shims/src/internal/internal_path.ts | 583 ++-- .../src/internal/internal_stringdecoder.ts | 193 +- .../shims/src/internal/internal_types.ts | 3 +- .../shims/src/internal/internal_utils.ts | 53 +- .../shims/src/internal/process.ts | 111 +- .../shims/src/internal/streams_adapters.js | 1195 +++---- .../shims/src/internal/streams_duplex.js | 828 ++--- .../shims/src/internal/streams_legacy.js | 130 +- .../shims/src/internal/streams_readable.js | 2978 ++++++++--------- .../shims/src/internal/streams_transform.d.ts | 640 ++-- .../shims/src/internal/streams_transform.js | 222 +- .../shims/src/internal/streams_util.js | 1668 +++++---- .../shims/src/internal/streams_writable.js | 1349 ++++---- .../shims/src/internal/util.d.ts | 11 +- .../wasmjs-engine/shims/src/internal/util.ts | 29 +- .../shims/src/internal/validators.ts | 50 +- .../crates/wasmjs-engine/shims/src/path.js | 11 +- .../wasmjs-engine/shims/src/path/posix.ts | 2 +- .../wasmjs-engine/shims/src/path/win32.ts | 2 +- JS/wasm/crates/wasmjs-engine/src/main.rs | 73 +- JS/wasm/crates/wasmjs-engine/taskfile.yml | 40 +- .../crates/wasmjs-engine/wasmjs-engine.wasm | Bin 5492465 -> 5163681 bytes JS/wasm/crates/wasmjs-runtime/Cargo.lock | 21 + JS/wasm/crates/wasmjs-runtime/Cargo.toml | 1 + JS/wasm/crates/wasmjs-runtime/src/bindings.rs | 73 +- JS/wasm/crates/wasmjs-runtime/src/handlers.rs | 14 +- JS/wasm/crates/wasmjs-runtime/src/io.rs | 3 +- JS/wasm/crates/wasmjs-runtime/src/routes.rs | 15 +- JS/wasm/crates/wasmjs-runtime/src/server.rs | 1 - JS/wasm/crates/wasmjs-runtime/src/store.rs | 3 +- .../crates/wasmjs-runtime/src/wiggle_abi.rs | 1 - .../wasmjs-runtime/src/wiggle_abi/geo_impl.rs | 4 - JS/wasm/crates/wasmjs-runtime/src/workers.rs | 12 +- JS/wasm/examples/ec-wasmjs-hono/build.js | 3 + .../examples/ec-wasmjs-hono/package-lock.json | 13 + JS/wasm/examples/ec-wasmjs-hono/package.json | 1 + JS/wasm/types/jsonnet/.gitignore | 6 + JS/wasm/types/jsonnet/Cargo.lock | 192 ++ JS/wasm/types/jsonnet/Cargo.toml | 19 + JS/wasm/types/jsonnet/package-lock.json | 26 + JS/wasm/types/jsonnet/package.json | 25 + JS/wasm/types/jsonnet/src/index.d.ts | 1 + JS/wasm/types/jsonnet/src/index.js | 5 + JS/wasm/types/jsonnet/src/lib.rs | 27 + JS/wasm/types/jsonnet/src/module.mjs | 7 + JS/wasm/types/jsonnet/tsconfig.json | 15 + 75 files changed, 9507 insertions(+), 9295 deletions(-) create mode 100644 JS/wasm/crates/wasmjs-engine/shims/src/arakoo-jsonnet.js create mode 100644 JS/wasm/types/jsonnet/.gitignore create mode 100644 JS/wasm/types/jsonnet/Cargo.lock create mode 100644 JS/wasm/types/jsonnet/Cargo.toml create mode 100644 JS/wasm/types/jsonnet/package-lock.json create mode 100644 JS/wasm/types/jsonnet/package.json create mode 100644 JS/wasm/types/jsonnet/src/index.d.ts create mode 100644 JS/wasm/types/jsonnet/src/index.js create mode 100644 JS/wasm/types/jsonnet/src/lib.rs create mode 100644 JS/wasm/types/jsonnet/src/module.mjs create mode 100644 JS/wasm/types/jsonnet/tsconfig.json diff --git a/JS/wasm/assets/wasmjs/wit/http-types.wit b/JS/wasm/assets/wasmjs/wit/http-types.wit index 2f5f9d9a6..41c3ecee1 100644 --- a/JS/wasm/assets/wasmjs/wit/http-types.wit +++ b/JS/wasm/assets/wasmjs/wit/http-types.wit @@ -38,4 +38,8 @@ enum http-error { internal-error, timeout, redirect-loop, -} \ No newline at end of file +} +enum file-error { + not-found, + invalid-path, +} diff --git a/JS/wasm/assets/wasmjs/wit/http.wit b/JS/wasm/assets/wasmjs/wit/http.wit index 36450be50..df2a5f05b 100644 --- a/JS/wasm/assets/wasmjs/wit/http.wit +++ b/JS/wasm/assets/wasmjs/wit/http.wit @@ -1,2 +1,4 @@ use * from http-types send-http-request: func(request: http-request) -> expected +parse-jsonnet: func(file: string) -> expected +read-bytes: func(file: string) -> expected diff --git a/JS/wasm/crates/wasmjs-engine/Cargo.lock b/JS/wasm/crates/wasmjs-engine/Cargo.lock index 36caa85ca..f950d0ccb 100644 --- a/JS/wasm/crates/wasmjs-engine/Cargo.lock +++ b/JS/wasm/crates/wasmjs-engine/Cargo.lock @@ -13,19 +13,19 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.75" +version = "1.0.76" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" +checksum = "59d2a3357dde987206219e78ecfbbb6e8dad06cbb65292758d3270e6254f7355" [[package]] name = "async-trait" -version = "0.1.74" +version = "0.1.75" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a66537f1bb974b254c98ed142ff995236e81b9d0fe4db0575f46612cb15eb0f9" +checksum = "fdf6721fb0140e4f897002dd086c06f6c27775df19cfe1fccb21181a48fd2c98" dependencies = [ "proc-macro2", "quote", - "syn 2.0.41", + "syn 2.0.42", ] [[package]] @@ -218,11 +218,11 @@ dependencies = [ [[package]] name = "home" -version = "0.5.5" +version = "0.5.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb" +checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -478,9 +478,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] name = "pkg-config" -version = "0.3.27" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" +checksum = "69d3587f8a9e599cc7ec2c00e331f71c4e69a5f9a4b8a6efd5b07466b9736f9a" [[package]] name = "proc-macro2" @@ -677,7 +677,7 @@ checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.41", + "syn 2.0.42", ] [[package]] @@ -720,9 +720,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.41" +version = "2.0.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44c8b28c477cc3bf0e7966561e3460130e1255f7a1cf71931075f1c5e7a7e269" +checksum = "5b7d0a2c048d661a1a59fcd7355baa232f7ed34e0ee4df2eef3c1c1c0d3852d8" dependencies = [ "proc-macro2", "quote", diff --git a/JS/wasm/crates/wasmjs-engine/package-lock.json b/JS/wasm/crates/wasmjs-engine/package-lock.json index 42532ba21..706944852 100644 --- a/JS/wasm/crates/wasmjs-engine/package-lock.json +++ b/JS/wasm/crates/wasmjs-engine/package-lock.json @@ -1,6 +1,6 @@ { - "name": "wasmjs-engine", - "lockfileVersion": 3, - "requires": true, - "packages": {} + "name": "wasmjs-engine", + "lockfileVersion": 3, + "requires": true, + "packages": {} } diff --git a/JS/wasm/crates/wasmjs-engine/shims/build.js b/JS/wasm/crates/wasmjs-engine/shims/build.js index 152ed75b8..87f18d436 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/build.js +++ b/JS/wasm/crates/wasmjs-engine/shims/build.js @@ -1,55 +1,68 @@ -import { build } from "esbuild"; +import { build } from 'esbuild' // Build for index.js build({ - entryPoints: ["src/index.js"], - bundle: true, - outfile: "dist/index.js", - format: "esm", - target: "esnext", - platform: "node", - treeShaking: false, + entryPoints: ['src/index.js'], + bundle: true, + outfile: 'dist/index.js', + format: "esm", + target: "esnext", + platform: "node", + treeShaking: false }).catch((error) => { - console.error(error); - process.exit(1); -}); + console.error(error) + process.exit(1) +}) // Build for buffer.js build({ - entryPoints: ["src/buffer.js"], - bundle: true, - outfile: "dist/buffer.js", - format: "esm", - target: "esnext", - platform: "node", - treeShaking: false, + entryPoints: ['src/buffer.js'], + bundle: true, + outfile: 'dist/buffer.js', + format: "esm", + target: "esnext", + platform: "node", + treeShaking: false }).catch((error) => { - console.error(error); - process.exit(1); -}); + console.error(error) + process.exit(1) +}) build({ - entryPoints: ["src/path.js"], - bundle: true, - outfile: "dist/path.js", - format: "esm", - target: "esnext", - platform: "node", - treeShaking: false, + entryPoints: ['src/path.js'], + bundle: true, + outfile: 'dist/path.js', + format: "esm", + target: "esnext", + platform: "node", + treeShaking: false }).catch((error) => { - console.error(error); - process.exit(1); -}); + console.error(error) + process.exit(1) +}) build({ - entryPoints: ["src/crypto.ts"], - bundle: true, - outfile: "dist/crypto.js", - format: "esm", - target: "esnext", - platform: "node", - treeShaking: false, + entryPoints: ['src/crypto.ts'], + bundle: true, + outfile: 'dist/crypto.js', + format: "esm", + target: "esnext", + platform: "node", + treeShaking: false }).catch((error) => { - console.error(error); - process.exit(1); -}); + console.error(error) + process.exit(1) +}) + +build({ + entryPoints: ['src/arakoo-jsonnet.js'], + bundle: true, + outfile: 'dist/arakoo-jsonnet.js', + format: "esm", + target: "esnext", + platform: "node", + treeShaking: false +}).catch((error) => { + console.error(error) + process.exit(1) +}) diff --git a/JS/wasm/crates/wasmjs-engine/shims/package.json b/JS/wasm/crates/wasmjs-engine/shims/package.json index da05da7b5..6d90997f4 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/package.json +++ b/JS/wasm/crates/wasmjs-engine/shims/package.json @@ -14,7 +14,7 @@ "buffer": "^6.0.3", "esbuild": "^0.19", "http-status": "^1.7", - "query-string": "^7.1.1", + "query-string": "^7.1.1", "sjcl": "^1.0.8", "url-parse": "^1.5.10" }, diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/arakoo-jsonnet.js b/JS/wasm/crates/wasmjs-engine/shims/src/arakoo-jsonnet.js new file mode 100644 index 000000000..bbb4e9df9 --- /dev/null +++ b/JS/wasm/crates/wasmjs-engine/shims/src/arakoo-jsonnet.js @@ -0,0 +1,5 @@ +const parseJsonnet = globalThis.parseJsonnet + +export { + parseJsonnet, +} diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/buffer.js b/JS/wasm/crates/wasmjs-engine/shims/src/buffer.js index 5d9131bf5..1dd28191f 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/buffer.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/buffer.js @@ -1,12 +1,19 @@ + import { constants, kMaxLength, kStringMaxLength, Buffer, SlowBuffer, -} from "./internal/internal_buffer"; +} from './internal/internal_buffer'; -export { constants, kMaxLength, kStringMaxLength, Buffer, SlowBuffer }; +export { + constants, + kMaxLength, + kStringMaxLength, + Buffer, + SlowBuffer, +}; export default { constants, @@ -14,4 +21,4 @@ export default { kStringMaxLength, Buffer, SlowBuffer, -}; +} \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/crypto.ts b/JS/wasm/crates/wasmjs-engine/shims/src/crypto.ts index f176cf637..0d504c138 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/crypto.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/crypto.ts @@ -1,4 +1,6 @@ -import { ERR_METHOD_NOT_IMPLEMENTED } from "./internal/internal_errors"; +import { + ERR_METHOD_NOT_IMPLEMENTED +} from './internal/internal_errors'; // export const getRandomValues = crypto.getRandomValues; // export const subtle = crypto.subtle; @@ -6,236 +8,209 @@ import { ERR_METHOD_NOT_IMPLEMENTED } from "./internal/internal_errors"; // export const webcrypto = crypto; import { - DiffieHellman, - DiffieHellmanGroup, - createDiffieHellman, - createDiffieHellmanGroup, - getDiffieHellman, -} from "./internal/crypto_dh"; + DiffieHellman, + DiffieHellmanGroup, + createDiffieHellman, + createDiffieHellmanGroup, + getDiffieHellman, +} from './internal/crypto_dh'; import { - randomBytes, - randomFillSync, - randomFill, - randomInt, - randomUUID, - PrimeNum, - GeneratePrimeOptions, - CheckPrimeOptions, - generatePrime, - generatePrimeSync, - checkPrime, - checkPrimeSync, -} from "./internal/crypto_random"; + randomBytes, + randomFillSync, + randomFill, + randomInt, + randomUUID, + PrimeNum, + GeneratePrimeOptions, + CheckPrimeOptions, + generatePrime, + generatePrimeSync, + checkPrime, + checkPrimeSync, +} from './internal/crypto_random'; -import { createHash, createHmac, Hash, HashOptions, Hmac } from "./internal/crypto_hash"; +import { + createHash, + createHmac, + Hash, + HashOptions, + Hmac, +} from './internal/crypto_hash'; -import { hkdf, hkdfSync } from "./internal/crypto_hkdf"; +import { + hkdf, + hkdfSync, +} from './internal/crypto_hkdf'; -import { pbkdf2, pbkdf2Sync, ArrayLike } from "./internal/crypto_pbkdf2"; +import { + pbkdf2, + pbkdf2Sync, + ArrayLike, +} from './internal/crypto_pbkdf2'; import { - KeyObject, - PublicKeyObject, - PrivateKeyObject, - SecretKeyObject, - generateKey, - generateKeyPair, - generateKeyPairSync, - generateKeySync, - createPrivateKey, - createPublicKey, - createSecretKey, -} from "./internal/crypto_keys"; + KeyObject, + PublicKeyObject, + PrivateKeyObject, + SecretKeyObject, + generateKey, + generateKeyPair, + generateKeyPairSync, + generateKeySync, + createPrivateKey, + createPublicKey, + createSecretKey, +} from './internal/crypto_keys'; export { - // DH - DiffieHellman, - DiffieHellmanGroup, - createDiffieHellman, - createDiffieHellmanGroup, - getDiffieHellman, - // Random - randomBytes, - randomFillSync, - randomFill, - randomInt, - randomUUID, - // Primes - PrimeNum as primeNum, - GeneratePrimeOptions as generatePrimeOptions, - CheckPrimeOptions as checkPrimeOptions, - generatePrime, - generatePrimeSync, - checkPrime, - checkPrimeSync, - // Hash and Hmac - createHash, - createHmac, - Hash, - HashOptions, - Hmac, - // Hkdf - hkdf, - hkdfSync, - // Pbkdf2 - pbkdf2, - pbkdf2Sync, - ArrayLike as arrayLike, - // Keys - KeyObject, - PublicKeyObject, - PrivateKeyObject, - SecretKeyObject, - generateKey, - generateKeyPair, - generateKeyPairSync, - generateKeySync, - createPrivateKey, - createPublicKey, - createSecretKey, -}; + // DH + DiffieHellman, + DiffieHellmanGroup, + createDiffieHellman, + createDiffieHellmanGroup, + getDiffieHellman, + // Random + randomBytes, + randomFillSync, + randomFill, + randomInt, + randomUUID, + // Primes + PrimeNum as primeNum, + GeneratePrimeOptions as generatePrimeOptions, + CheckPrimeOptions as checkPrimeOptions, + generatePrime, + generatePrimeSync, + checkPrime, + checkPrimeSync, + // Hash and Hmac + createHash, + createHmac, + Hash, + HashOptions, + Hmac, + // Hkdf + hkdf, + hkdfSync, + // Pbkdf2 + pbkdf2, + pbkdf2Sync, + ArrayLike as arrayLike, + // Keys + KeyObject, + PublicKeyObject, + PrivateKeyObject, + SecretKeyObject, + generateKey, + generateKeyPair, + generateKeyPairSync, + generateKeySync, + createPrivateKey, + createPublicKey, + createSecretKey, +} export function getCiphers() { - return [ - "aes-128-cbc", - "aes-192-cbc", - "aes-256-cbc", - "aes-128-ctr", - "aes-192-ctr", - "aes-256-ctr", - "aes-128-ecb", - "aes-192-ecb", - "aes-256-ecb", - "aes-128-gcm", - "aes-192-gcm", - "aes-256-gcm", - "aes-128-ofb", - "aes-192-ofb", - "aes-256-ofb", - "des-ecb", - "des-ede", - "des-ede-cbc", - "rc2-cbc", - ]; + return ["aes-128-cbc", "aes-192-cbc", "aes-256-cbc", "aes-128-ctr", "aes-192-ctr", "aes-256-ctr", + "aes-128-ecb", "aes-192-ecb", "aes-256-ecb", "aes-128-gcm", "aes-192-gcm", "aes-256-gcm", + "aes-128-ofb", "aes-192-ofb", "aes-256-ofb", "des-ecb", "des-ede", "des-ede-cbc", "rc2-cbc"]; } export function getCurves() { - // Hardcoded list of supported curves. Note that prime256v1 is equivalent to secp256r1, we follow - // OpenSSL's and bssl's nomenclature here. - return ["secp224r1", "prime256v1", "secp384r1", "secp521r1"]; + // Hardcoded list of supported curves. Note that prime256v1 is equivalent to secp256r1, we follow + // OpenSSL's and bssl's nomenclature here. + return ['secp224r1', 'prime256v1', 'secp384r1', 'secp521r1']; } export function getHashes() { - // Hardcoded list of hashes supported in boringssl, node's approach looks pretty clunky. This is - // expected to change infrequently based of bssl's stability-focused approach. - return [ - "md4", - "md5", - "sha1", - "sha224", - "sha256", - "sha384", - "sha512", - "md5-sha1", - "RSA-MD5", - "RSA-SHA1", - "RSA-SHA224", - "RSA-SHA256", - "RSA-SHA384", - "RSA-SHA512", - "DSA-SHA", - "DSA-SHA1", - "ecdsa-with-SHA1", - ]; + // Hardcoded list of hashes supported in boringssl, node's approach looks pretty clunky. This is + // expected to change infrequently based of bssl's stability-focused approach. + return ['md4', 'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5-sha1', 'RSA-MD5', + 'RSA-SHA1', 'RSA-SHA224', 'RSA-SHA256', 'RSA-SHA384', 'RSA-SHA512', 'DSA-SHA', + 'DSA-SHA1', 'ecdsa-with-SHA1']; } // We do not implement the openssl secure heap. export function secureHeapUsed() { - return { - total: 0, - used: 0, - utilization: 0, - min: 0, - }; + return { + total: 0, + used: 0, + utilization: 0, + min: 0, + } } // We do not allow users to set the engine used. -export function setEngine(_1: string, _2?: number) { - throw new ERR_METHOD_NOT_IMPLEMENTED("setEngine"); +export function setEngine(_1 : string, _2?: number) { + throw new ERR_METHOD_NOT_IMPLEMENTED('setEngine'); } // We do not allow users to modify the FIPS enablement. export function setFips(_: boolean) { - throw new ERR_METHOD_NOT_IMPLEMENTED("setFips"); + throw new ERR_METHOD_NOT_IMPLEMENTED('setFips'); } // We always run in FIPS mode. export const fips = true; -export function getFips() { - return fips; -} +export function getFips() { return fips; } export default { - // DH - DiffieHellman, - DiffieHellmanGroup, - createDiffieHellman, - createDiffieHellmanGroup, - getDiffieHellman, - // Keys, - KeyObject, - PublicKeyObject, - PrivateKeyObject, - SecretKeyObject, - generateKey, - generateKeyPair, - generateKeyPairSync, - generateKeySync, - createPrivateKey, - createPublicKey, - createSecretKey, - // Random - // getRandomValues, - randomBytes, - randomFillSync, - randomFill, - randomInt, - randomUUID, - generatePrime, - generatePrimeSync, - checkPrime, - checkPrimeSync, - // Hash and Hmac - Hash, - Hmac, - createHash, - createHmac, - getHashes, - // Hkdf - hkdf, - hkdfSync, - // Pbkdf2 - pbkdf2, - pbkdf2Sync, - // Misc - getCiphers, - getCurves, - secureHeapUsed, - setEngine, - // timingSafeEqual, - // Fips - getFips, - setFips, - get fips() { - return getFips(); - }, - set fips(_: boolean) { - setFips(_); - }, - // WebCrypto - // subtle, - // webcrypto, + // DH + DiffieHellman, + DiffieHellmanGroup, + createDiffieHellman, + createDiffieHellmanGroup, + getDiffieHellman, + // Keys, + KeyObject, + PublicKeyObject, + PrivateKeyObject, + SecretKeyObject, + generateKey, + generateKeyPair, + generateKeyPairSync, + generateKeySync, + createPrivateKey, + createPublicKey, + createSecretKey, + // Random + // getRandomValues, + randomBytes, + randomFillSync, + randomFill, + randomInt, + randomUUID, + generatePrime, + generatePrimeSync, + checkPrime, + checkPrimeSync, + // Hash and Hmac + Hash, + Hmac, + createHash, + createHmac, + getHashes, + // Hkdf + hkdf, + hkdfSync, + // Pbkdf2 + pbkdf2, + pbkdf2Sync, + // Misc + getCiphers, + getCurves, + secureHeapUsed, + setEngine, + // timingSafeEqual, + // Fips + getFips, + setFips, + get fips() { return getFips(); }, + set fips(_: boolean) { setFips(_); }, + // WebCrypto + // subtle, + // webcrypto, }; // Classes @@ -319,3 +294,4 @@ export default { // * WebCrypto // * [x] crypto.subtle // * [x] crypto.webcrypto + diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/events.ts b/JS/wasm/crates/wasmjs-engine/shims/src/events.ts index 1772e3e84..938ed3c44 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/events.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/events.ts @@ -3,5 +3,5 @@ // https://opensource.org/licenses/Apache-2.0 // -export * from "./internal/events"; -export { default } from "./internal/events"; +export * from './internal/events'; +export { default } from './internal/events'; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/index.js b/JS/wasm/crates/wasmjs-engine/shims/src/index.js index 2fa1129e0..9c29c339f 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/index.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/index.js @@ -1,110 +1,112 @@ // import { URLSearchParams } from "@ungap/url-search-params"; import { TextEncoder, TextDecoder } from "@sinonjs/text-encoding"; import httpStatus from "http-status"; -import Url from "url-parse"; -import _queryString from "query-string"; +import Url from 'url-parse' +import _queryString from 'query-string'; class URL { + constructor(urlStr, base = undefined) { - let url = Url(urlStr, base); - this.url = url; - this.protocol = url.protocol; - this.slashes = url.slashes; - this.auth = url.auth; - this.username = url.username; - this.password = url.password; - this.host = url.host; - this.port = url.port; - this.pathname = url.pathname; - this.search = url.query; - this.searchParams = new URLSearchParams(this.search); - this.hash = url.hash; - this.href = url.origin; - this.origin = url.origin; + let url = Url(urlStr, base) + this.url = url + this.protocol = url.protocol + this.slashes = url.slashes + this.auth = url.auth + this.username = url.username + this.password = url.password + this.host = url.host + this.port = url.port + this.pathname = url.pathname + this.search = url.query + this.searchParams = new URLSearchParams(this.search) + this.hash = url.hash + this.href = url.origin + this.origin = url.origin } set(key, value) { - this.url.set(key, value); + this.url.set(key, value) } toString() { - return this.url.toString(); + return this.url.toString() } toJson() { - return this.url.toString(); + return this.url.toString() } + } class URLSearchParams { - queryParams = {}; + queryParams = {} constructor(val) { this.queryParams = { - ..._queryString.parse(val), - }; + ..._queryString.parse(val) + } } append(key, val) { - this.queryParams[key] = val; + this.queryParams[key] = val } delete(key) { - delete this.queryParams[key]; + delete this.queryParams[key] } entries() { - let arr = []; - Object.entries(this.queryParams).map((o) => { + let arr = [] + Object.entries(this.queryParams).map(o => { if (Array.isArray(o[1])) { - o[1].map((k) => { - arr.push([o[0], k]); - }); + o[1].map(k => { + arr.push([o[0], k]) + }) } else { - arr.push([o[0], o[1]]); + arr.push([o[0], o[1]]) } - }); - let iterLength = arr.length; - let iterIndex = 0; + }) + let iterLength = arr.length + let iterIndex = 0 return { next: function () { - return iterIndex < iterLength - ? { value: arr[iterIndex++], done: false } - : { done: true }; - }, - }; + return iterIndex < iterLength ? + { value: arr[iterIndex++], done: false } : + { done: true }; + } + } } get(key) { - let val = this.queryParams[key]; + let val = this.queryParams[key] if (val) { - if (typeof val == "object") { - return val[0]; + if (typeof (val) == "object") { + return val[0] } - return val; + return val } - return null; + return null } getAll(key) { - let val = this.queryParams[key]; + let val = this.queryParams[key] if (val) { - return val; + return val } - return null; + return null } has(key) { - return this.queryParams[key] != undefined ? true : false; + return this.queryParams[key] != undefined ? true : false } keys() { - return Object.keys(this.queryParams); + return Object.keys(this.queryParams) } set(key, val) { - this.queryParams[key] = val; + this.queryParams[key] = val } toString() { - return _queryString.stringify(this.queryParams); + return _queryString.stringify(this.queryParams) } values() { - return Object.keys(this.queryParams).map((k) => this.queryParams[k]); + return Object.keys(this.queryParams).map(k => this.queryParams[k]) } [Symbol.iterator]() { - return this.entries(); + return this.entries() } } @@ -112,11 +114,11 @@ globalThis.URL = URL; globalThis.URLSearchParams = URLSearchParams; function atob(b64) { - return Buffer.from(b64, "base64").toString(); + return Buffer.from(b64, "base64").toString() } function btoa(data) { - return Buffer.from(data).toString("base64"); + return Buffer.from(data).toString('base64') } globalThis.btoa = btoa; @@ -205,9 +207,9 @@ class Response { return new Response(`Redirecting to ${url}`, { status, headers: { - Location: url, - }, - }); + Location: url + } + }) } get ok() { @@ -278,14 +280,14 @@ class Response { method: "GET", headers: {}, body: null, - ...opts, + ...opts }; if (optsWithDefault.body !== null && typeof optsWithDefault.body !== "string") { try { optsWithDefault.body = new TextEncoder().encode(optsWithDefault.body); } catch (e) { - return Promise.reject(`err: ${e}`); + return Promise.reject(`err: ${e}`) } } @@ -297,11 +299,12 @@ class Response { let response = new Response(result.body, { headers: result.headers, status: result.status, - }); + }) return Promise.resolve(response); } - }; + } + globalThis.console = { error(msg) { @@ -321,8 +324,8 @@ class Response { }, trace(msg) { this.log(msg); - }, - }; + } + } Reflect.deleteProperty(globalThis, "__send_http_request"); Reflect.deleteProperty(globalThis, "__console_log"); @@ -337,27 +340,28 @@ globalThis.addEventListener = (_eventName, handler) => { handlerFunction = handler; }; -const requestToHandler = (input) => { +const requestToHandler = input => { const request = new Request(input); const event = { request, response: {}, respondWith(res) { this.response = res; - }, + } }; try { handlerFunction(event); - Promise.resolve(event.response) - .then((res) => { - result = { - data: res.body, - headers: res.headers.headers, - status: res.status, - }; - }) + Promise.resolve( + event.response + ).then(res => { + result = { + data: res.body, + headers: res.headers.headers, + status: res.status, + }; + }) .catch((err) => { error = `err: \n${err}`; }); @@ -368,4 +372,4 @@ const requestToHandler = (input) => { globalThis.entrypoint = requestToHandler; globalThis.result = {}; -globalThis.error = null; +globalThis.error = null diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.d.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.d.ts index 6f02fb827..4e97d10a0 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.d.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.d.ts @@ -1,26 +1,22 @@ // Type definitions for c++ implementation. export interface AsyncResourceOptions { - triggerAsyncId?: number; + triggerAsyncId?: number; } export class AsyncResource { - public constructor(type: string, options?: AsyncResourceOptions); - public runInAsyncScope(fn: (...args: unknown[]) => R, ...args: unknown[]): R; + public constructor(type: string, options?: AsyncResourceOptions); + public runInAsyncScope(fn: (...args: unknown[]) => R, ...args: unknown[]): R; - public bind unknown>( - fn: Func - ): Func & { asyncResource: AsyncResource }; + public bind unknown>( + fn: Func): Func & { asyncResource: AsyncResource; }; - public static bind unknown, ThisArg>( - fn: Func, - type?: string, - thisArg?: ThisArg - ): Func & { asyncResource: AsyncResource }; + public static bind unknown, ThisArg>( + fn: Func, type?: string, thisArg?: ThisArg): Func & { asyncResource: AsyncResource; }; } export class AsyncLocalStorage { - public run(store: T, fn: (...args: unknown[]) => R, ...args: unknown[]): R; - public exit(fn: (...args: unknown[]) => R, ...args: unknown[]): R; - public getStore(): T; + public run(store: T, fn: (...args: unknown[]) => R, ...args: unknown[]): R; + public exit(fn: (...args: unknown[]) => R, ...args: unknown[]): R; + public getStore(): T; } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.ts index 968aa2fc3..a78e2a726 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/async_hooks.ts @@ -9,15 +9,11 @@ export class AsyncResource { public runInAsyncScope(fn: (...args: unknown[]) => R, ...args: unknown[]): R; public bind unknown>( - fn: Func - ): Func & { asyncResource: AsyncResource }; + fn: Func): Func & { asyncResource: AsyncResource; }; // @ts-ignore public static bind unknown, ThisArg>( - fn: Func, - type?: string, - thisArg?: ThisArg - ): Func & { asyncResource: AsyncResource }; + fn: Func, type?: string, thisArg?: ThisArg): Func & { asyncResource: AsyncResource; }; } export class AsyncLocalStorage { diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.d.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.d.ts index 6ba318865..d387b6aa6 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.d.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.d.ts @@ -1,8 +1,9 @@ + export interface CompareOptions { aStart?: number; aEnd?: number; bStart?: number; - bEnd?: number; + bEnd?: number } type BufferSource = ArrayBufferView | ArrayBuffer; @@ -11,28 +12,25 @@ export function byteLength(value: string): number; export function compare(a: Uint8Array, b: Uint8Array, options?: CompareOptions): number; export function concat(list: Uint8Array[], length: number): ArrayBuffer; export function decodeString(value: string, encoding: string): ArrayBuffer; -export function fillImpl( - buffer: Uint8Array, - value: string | BufferSource, - start: number, - end: number, - encoding?: string -): void; -export function indexOf( - buffer: Uint8Array, - value: string | Uint8Array, - byteOffset?: number, - encoding?: string, - findLast?: boolean -): number | undefined; -export function swap(buffer: Uint8Array, size: 16 | 32 | 64): void; -export function toString(buffer: Uint8Array, start: number, end: number, encoding: string): string; -export function write( - buffer: Uint8Array, - value: string, - offset: number, - length: number, - encoding: string -): void; +export function fillImpl(buffer: Uint8Array, + value: string | BufferSource, + start: number, + end: number, + encoding?: string): void; +export function indexOf(buffer: Uint8Array, + value: string | Uint8Array, + byteOffset?: number, + encoding?: string, + findLast?: boolean): number | undefined; +export function swap(buffer: Uint8Array, size: 16|32|64): void; +export function toString(buffer: Uint8Array, + start: number, + end: number, + encoding: string): string; +export function write(buffer: Uint8Array, + value: string, + offset: number, + length: number, + encoding: string): void; export function decode(buffer: Uint8Array, state: Uint8Array): string; -export function flush(state: Uint8Array): string; +export function flush(state: Uint8Array): string; \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.ts index 21fde0761..8ea27b939 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/buffer.ts @@ -1,521 +1,539 @@ -import { isInstance } from "./internal_buffer"; +import {isInstance} from "./internal_buffer"; import * as base64 from "base64-js"; import { TextEncoder, TextDecoder } from "@sinonjs/text-encoding"; const hexCharValueTable = { - "0": 0, - "1": 1, - "2": 2, - "3": 3, - "4": 4, - "5": 5, - "6": 6, - "7": 7, - "8": 8, - "9": 9, - a: 10, - b: 11, - c: 12, - d: 13, - e: 14, - f: 15, - A: 10, - B: 11, - C: 12, - D: 13, - E: 14, - F: 15, + "0": 0, + "1": 1, + "2": 2, + "3": 3, + "4": 4, + "5": 5, + "6": 6, + "7": 7, + "8": 8, + "9": 9, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, }; export function byteLength(string, encoding) { - if (Buffer.isBuffer(string)) { - return string.length; - } - if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { - return string.byteLength; - } - if (typeof string !== "string") { - throw new TypeError( - 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + - "Received type " + - typeof string - ); - } - - const len = string.length; - const mustMatch = arguments.length > 2 && arguments[2] === true; - if (!mustMatch && len === 0) return 0; - - // Use a for loop to avoid recursion - let loweredCase = false; - for (;;) { - switch (encoding) { - case "ascii": - case "latin1": - case "binary": - return len; - case "utf8": - case "utf-8": - return utf8ToBytes(string).length; - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return len * 2; - case "hex": - return len >>> 1; - case "base64": - return base64ToBytes(string).length; - default: - if (loweredCase) { - return mustMatch ? -1 : utf8ToBytes(string).length; // assume utf8 - } - encoding = ("" + encoding).toLowerCase(); - loweredCase = true; + if (Buffer.isBuffer(string)) { + return string.length; + } + if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { + return string.byteLength; + } + if (typeof string !== "string") { + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + + "Received type " + + typeof string + ); + } + + const len = string.length; + const mustMatch = arguments.length > 2 && arguments[2] === true; + if (!mustMatch && len === 0) return 0; + + // Use a for loop to avoid recursion + let loweredCase = false; + for (;;) { + switch (encoding) { + case "ascii": + case "latin1": + case "binary": + return len; + case "utf8": + case "utf-8": + return utf8ToBytes(string).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return len * 2; + case "hex": + return len >>> 1; + case "base64": + return base64ToBytes(string).length; + default: + if (loweredCase) { + return mustMatch ? -1 : utf8ToBytes(string).length; // assume utf8 } + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; } + } } // @ts-ignore export function compare(a: Uint8Array, b: Uint8Array, options?): number { - const aStart = options?.aStart ?? 0; - const aEnd = options?.aEnd ?? a.length; - const bStart = options?.bStart ?? 0; - const bEnd = options?.bEnd ?? b.length; - - const sliceA = a.slice(aStart, aEnd); - const sliceB = b.slice(bStart, bEnd); - - let x = sliceA.length; - let y = sliceB.length; - - for (let i = 0, len = Math.min(x, y); i < len; ++i) { - if (sliceA[i] !== sliceB[i]) { - x = sliceA[i]; - y = sliceB[i]; - break; - } + const aStart = options?.aStart ?? 0; + const aEnd = options?.aEnd ?? a.length; + const bStart = options?.bStart ?? 0; + const bEnd = options?.bEnd ?? b.length; + + const sliceA = a.slice(aStart, aEnd); + const sliceB = b.slice(bStart, bEnd); + + let x = sliceA.length; + let y = sliceB.length; + + for (let i = 0, len = Math.min(x, y); i < len; ++i) { + if (sliceA[i] !== sliceB[i]) { + x = sliceA[i]; + y = sliceB[i]; + break; } + } - if (x < y) return -1; - if (y < x) return 1; - return 0; + if (x < y) return -1; + if (y < x) return 1; + return 0; } export function concat(list: Uint8Array[], length: number): ArrayBuffer { - const result = new Uint8Array(length); - let offset = 0; - for (let i = 0; i < list.length; i++) { - result.set(list[i], offset); - offset += list[i].length; - } - return result.buffer; + const result = new Uint8Array(length); + let offset = 0; + for (let i = 0; i < list.length; i++) { + result.set(list[i], offset); + offset += list[i].length; + } + return result.buffer; } -export function toString(buffer: Uint8Array, start: number, end: number, encoding: string): string { - const slice = buffer.slice(start, end); - const decoder = new TextDecoder(encoding); - return decoder.decode(slice); +export function toString( + buffer: Uint8Array, + start: number, + end: number, + encoding: string +): string { + const slice = buffer.slice(start, end); + const decoder = new TextDecoder(encoding); + return decoder.decode(slice); } export function swap(buffer: Uint8Array, size: 16 | 32 | 64): void { - const length = buffer.length; - if (length % size !== 0) { - throw new RangeError("Buffer size must be a multiple of " + size); - } - - for (let i = 0; i < length; i += size) { - let left = i; - let right = i + size - 1; - while (left < right) { - const temp = buffer[left]; - buffer[left] = buffer[right]; - buffer[right] = temp; - left++; - right--; - } + const length = buffer.length; + if (length % size !== 0) { + throw new RangeError("Buffer size must be a multiple of " + size); + } + + for (let i = 0; i < length; i += size) { + let left = i; + let right = i + size - 1; + while (left < right) { + const temp = buffer[left]; + buffer[left] = buffer[right]; + buffer[right] = temp; + left++; + right--; } + } } export function decodeString(value: string, encoding: string): ArrayBuffer { - const encoder = new TextEncoder(); - return encoder.encode(value).buffer; + const encoder = new TextEncoder(); + return encoder.encode(value).buffer; } export function write( - buffer: Uint8Array, - value: string, - offset: number, - length: number, - encoding: string + buffer: Uint8Array, + value: string, + offset: number, + length: number, + encoding: string ): void { - let loweredCase = false; - for (;;) { - switch (encoding) { - case "hex": - return hexWrite(buffer, value, offset, length); - - case "utf8": - case "utf-8": - return utf8Write(buffer, value, offset, length); - - case "ascii": - case "latin1": - case "binary": - return asciiWrite(buffer, value, offset, length); - - case "base64": - // Warning: maxLength not taken into account in base64Write - return base64Write(buffer, value, offset, length); - - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return ucs2Write(buffer, value, offset, length); - - default: - if (loweredCase) throw new TypeError("Unknown encoding: " + encoding); - encoding = ("" + encoding).toLowerCase(); - loweredCase = true; - } + let loweredCase = false; + for (;;) { + switch (encoding) { + case "hex": + return hexWrite(buffer, value, offset, length); + + case "utf8": + case "utf-8": + return utf8Write(buffer, value, offset, length); + + case "ascii": + case "latin1": + case "binary": + return asciiWrite(buffer, value, offset, length); + + case "base64": + // Warning: maxLength not taken into account in base64Write + return base64Write(buffer, value, offset, length); + + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return ucs2Write(buffer, value, offset, length); + + default: + if (loweredCase) throw new TypeError("Unknown encoding: " + encoding); + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; } + } } export function fillImpl( - buffer: Uint8Array, - val: string | BufferSource | number | boolean, - start: number, - end: number, - encoding?: string + buffer: Uint8Array, + val: string | BufferSource | number | boolean, + start: number, + end: number, + encoding?: string ): void { - let i; - if (typeof val === "number") { - for (i = start; i < end; ++i) { - buffer[i] = val; - } - } else { - const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val as string, encoding); - const len = bytes.length; - for (i = 0; i < end - start; ++i) { - buffer[i + start] = bytes[i % len]; - } + let i; + if (typeof val === "number") { + for (i = start; i < end; ++i) { + buffer[i] = val; + } + } else { + const bytes = Buffer.isBuffer(val) + ? val + : Buffer.from(val as string, encoding); + const len = bytes.length; + for (i = 0; i < end - start; ++i) { + buffer[i + start] = bytes[i % len]; } + } } export function indexOf(buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1; - - // Normalize byteOffset - if (typeof byteOffset === "string") { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (numberIsNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : buffer.length - 1; - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1; - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1; +// Empty buffer means no match + if (buffer.length === 0) return -1; + + // Normalize byteOffset + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff; + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000; + } + byteOffset = +byteOffset; // Coerce to Number. + if (numberIsNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : buffer.length - 1; + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset; + if (byteOffset >= buffer.length) { + if (dir) return -1; + else byteOffset = buffer.length - 1; + } else if (byteOffset < 0) { + if (dir) byteOffset = 0; + else return -1; + } + + // Normalize val + if (typeof val === "string") { + val = Buffer.from(val, encoding); + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1; } - - // Normalize val - if (typeof val === "string") { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (Buffer.isBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1; - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir); - } else if (typeof val === "number") { - val = val & 0xff; // Search for a byte value [0-255] - if (typeof Uint8Array.prototype.indexOf === "function") { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset); - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset); - } - } - return arrayIndexOf(buffer, [val], byteOffset, encoding, dir); + return arrayIndexOf(buffer, val, byteOffset, encoding, dir); + } else if (typeof val === "number") { + val = val & 0xff; // Search for a byte value [0-255] + if (typeof Uint8Array.prototype.indexOf === "function") { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset); + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset); + } } + return arrayIndexOf(buffer, [val], byteOffset, encoding, dir); + } - throw new TypeError("val must be string, number or Buffer"); + throw new TypeError("val must be string, number or Buffer"); } function arrayIndexOf(arr, val, byteOffset, encoding, dir) { - let indexSize = 1; - let arrLength = arr.length; - let valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if ( - encoding === "ucs2" || - encoding === "ucs-2" || - encoding === "utf16le" || - encoding === "utf-16le" - ) { - if (arr.length < 2 || val.length < 2) { - return -1; - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read(buf, i) { - if (indexSize === 1) { - return buf[i]; - } else { - return buf.readUInt16BE(i * indexSize); - } + let indexSize = 1; + let arrLength = arr.length; + let valLength = val.length; + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase(); + if ( + encoding === "ucs2" || + encoding === "ucs-2" || + encoding === "utf16le" || + encoding === "utf-16le" + ) { + if (arr.length < 2 || val.length < 2) { + return -1; + } + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; } + } - let i; - if (dir) { - let foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize; - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } + function read(buf, i) { + if (indexSize === 1) { + return buf[i]; } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - let found = true; - for (let j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break; - } - } - if (found) return i; + return buf.readUInt16BE(i * indexSize); + } + } + + let i; + if (dir) { + let foundIndex = -1; + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i; + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize; + } else { + if (foundIndex !== -1) i -= i - foundIndex; + foundIndex = -1; + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; + for (i = byteOffset; i >= 0; i--) { + let found = true; + for (let j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false; + break; } + } + if (found) return i; } + } - return -1; + return -1; } function utf8ToBytes(string, units?) { - units = units || Infinity; - let codePoint; - const length = string.length; - let leadSurrogate = null; - const bytes = []; - - for (let i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xd7ff && codePoint < 0xe000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xdbff) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); - continue; - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); - continue; - } - - // valid lead - leadSurrogate = codePoint; - - continue; - } - - // 2 leads in a row - if (codePoint < 0xdc00) { - if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); - leadSurrogate = codePoint; - continue; - } - - // valid surrogate pair - codePoint = (((leadSurrogate - 0xd800) << 10) | (codePoint - 0xdc00)) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + + for (let i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i); + + // is surrogate component + if (codePoint > 0xd7ff && codePoint < 0xe000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xdbff) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); + continue; + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); + continue; } - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break; - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break; - bytes.push((codePoint >> 0x6) | 0xc0, (codePoint & 0x3f) | 0x80); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break; - bytes.push( - (codePoint >> 0xc) | 0xe0, - ((codePoint >> 0x6) & 0x3f) | 0x80, - (codePoint & 0x3f) | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break; - bytes.push( - (codePoint >> 0x12) | 0xf0, - ((codePoint >> 0xc) & 0x3f) | 0x80, - ((codePoint >> 0x6) & 0x3f) | 0x80, - (codePoint & 0x3f) | 0x80 - ); - } else { - throw new Error("Invalid code point"); - } + // valid lead + leadSurrogate = codePoint; + + continue; + } + + // 2 leads in a row + if (codePoint < 0xdc00) { + if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); + leadSurrogate = codePoint; + continue; + } + + // valid surrogate pair + codePoint = + (((leadSurrogate - 0xd800) << 10) | (codePoint - 0xdc00)) + 0x10000; + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); } - return bytes; -} - -function hexWrite(buf, string, offset, length) { - offset = Number(offset) || 0; - const remaining = buf.length - offset; - if (!length) { - length = remaining; + leadSurrogate = null; + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break; + bytes.push(codePoint); + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break; + bytes.push((codePoint >> 0x6) | 0xc0, (codePoint & 0x3f) | 0x80); + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break; + bytes.push( + (codePoint >> 0xc) | 0xe0, + ((codePoint >> 0x6) & 0x3f) | 0x80, + (codePoint & 0x3f) | 0x80 + ); + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break; + bytes.push( + (codePoint >> 0x12) | 0xf0, + ((codePoint >> 0xc) & 0x3f) | 0x80, + ((codePoint >> 0x6) & 0x3f) | 0x80, + (codePoint & 0x3f) | 0x80 + ); } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } + throw new Error("Invalid code point"); } + } - const strLen = string.length; + return bytes; +} - if (length > strLen / 2) { - length = strLen / 2; +function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; } - let i; - for (i = 0; i < length; ++i) { - const a = hexCharValueTable[string[i * 2]]; - const b = hexCharValueTable[string[i * 2 + 1]]; - if (a === undefined || b === undefined) { - return i; - } - buf[offset + i] = (a << 4) | b; + } + + const strLen = string.length; + + if (length > strLen / 2) { + length = strLen / 2; + } + let i; + for (i = 0; i < length; ++i) { + const a = hexCharValueTable[string[i * 2]]; + const b = hexCharValueTable[string[i * 2 + 1]]; + if (a === undefined || b === undefined) { + return i; } - return i; + buf[offset + i] = (a << 4) | b; + } + return i; } function base64ToBytes(str) { - return base64.toByteArray(base64clean(str)); + return base64.toByteArray(base64clean(str)); } function utf8Write(buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length); + return blitBuffer( + utf8ToBytes(string, buf.length - offset), + buf, + offset, + length + ); } function asciiWrite(buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length); + return blitBuffer(asciiToBytes(string), buf, offset, length); } function base64Write(buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length); + return blitBuffer(base64ToBytes(string), buf, offset, length); } function ucs2Write(buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length); + return blitBuffer( + utf16leToBytes(string, buf.length - offset), + buf, + offset, + length + ); } function asciiToBytes(str) { - const byteArray = []; - for (let i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xff); - } - return byteArray; + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xff); + } + return byteArray; } function utf16leToBytes(str, units) { - let c, hi, lo; - const byteArray = []; - for (let i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break; - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray; + let c, hi, lo; + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break; + + c = str.charCodeAt(i); + hi = c >> 8; + lo = c % 256; + byteArray.push(lo); + byteArray.push(hi); + } + + return byteArray; } const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g; function base64clean(str) { - // Node takes equal signs as end of the Base64 encoding - str = str.split("=")[0]; - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = str.trim().replace(INVALID_BASE64_RE, ""); - // Node converts strings with length < 2 to '' - if (str.length < 2) return ""; - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + "="; - } - return str; + // Node takes equal signs as end of the Base64 encoding + str = str.split("=")[0]; + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = str.trim().replace(INVALID_BASE64_RE, ""); + // Node converts strings with length < 2 to '' + if (str.length < 2) return ""; + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + "="; + } + return str; } function blitBuffer(src, dst, offset, length) { - let i; - for (i = 0; i < length; ++i) { - if (i + offset >= dst.length || i >= src.length) break; - dst[i + offset] = src[i]; - } - return i; + let i; + for (i = 0; i < length; ++i) { + if (i + offset >= dst.length || i >= src.length) break; + dst[i + offset] = src[i]; + } + return i; } function numberIsNaN(obj) { - // For IE11 support - return obj !== obj; // eslint-disable-line no-self-compare + // For IE11 support + return obj !== obj; // eslint-disable-line no-self-compare } export function flush(state: Uint8Array): string { - // Create a new Uint8Array object from the state. - const buffer = new Uint8Array(state); - return String.fromCharCode.apply(null, buffer); + // Create a new Uint8Array object from the state. + const buffer = new Uint8Array(state); + return String.fromCharCode.apply(null, buffer); } export function decode(buffer: Uint8Array, state: Uint8Array): string { - let result = ""; - for (let i = 0; i < buffer.length; i++) { - const byte = buffer[i]; - const char = state[byte]; - if (char === undefined) { - throw new Error("Invalid byte"); - } - result += char; + let result = ""; + for (let i = 0; i < buffer.length; i++) { + const byte = buffer[i]; + const char = state[byte]; + if (char === undefined) { + throw new Error("Invalid byte"); } - return result; -} + result += char; + } + return result; +} \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/constants.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/constants.ts index 2013d207f..88ec50573 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/constants.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/constants.ts @@ -1,3 +1,4 @@ + export const CHAR_UPPERCASE_A = 65; /* A */ export const CHAR_LOWERCASE_A = 97; /* a */ export const CHAR_UPPERCASE_Z = 90; /* Z */ @@ -41,4 +42,4 @@ export const CHAR_AMPERSAND = 38; /* & */ export const CHAR_EQUAL = 61; /* = */ export const CHAR_0 = 48; /* 0 */ export const CHAR_9 = 57; /* 9 */ -export const EOL = ";"; +export const EOL = '\;'; \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.d.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.d.ts index afab20186..6fb967959 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.d.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.d.ts @@ -1,47 +1,35 @@ -import { Buffer } from "./internal_buffer"; +import { + Buffer, +} from './internal_buffer'; // random export function checkPrimeSync(candidate: ArrayBufferView, num_checks: number): boolean; -export function randomPrime( - size: number, - safe: boolean, - add?: ArrayBufferView | undefined, - rem?: ArrayBufferView | undefined -): ArrayBuffer; +export function randomPrime(size: number, safe: boolean, add?: ArrayBufferView|undefined, + rem?: ArrayBufferView|undefined): ArrayBuffer; // Hash and Hmac export class HashHandle { - public constructor(algorithm: string, xofLen: number); - public update(data: Buffer | ArrayBufferView): number; - public digest(): ArrayBuffer; - public copy(xofLen: number): HashHandle; + public constructor(algorithm: string, xofLen: number); + public update(data: Buffer | ArrayBufferView): number; + public digest(): ArrayBuffer; + public copy(xofLen: number): HashHandle; } -export type ArrayLike = ArrayBuffer | string | Buffer | ArrayBufferView; +export type ArrayLike = ArrayBuffer|string|Buffer|ArrayBufferView; export class HmacHandle { - public constructor(algorithm: string, key: ArrayLike | CryptoKey); - public update(data: Buffer | ArrayBufferView): number; - public digest(): ArrayBuffer; + public constructor(algorithm: string, key: ArrayLike | CryptoKey); + public update(data: Buffer | ArrayBufferView): number; + public digest(): ArrayBuffer; } // hkdf -export function getHkdf( - hash: string, - key: ArrayLike, - salt: ArrayLike, - info: ArrayLike, - length: number -): ArrayBuffer; +export function getHkdf(hash: string, key: ArrayLike, salt: ArrayLike, info: ArrayLike, + length: number): ArrayBuffer; // pbkdf2 -export function getPbkdf( - password: ArrayLike, - salt: ArrayLike, - iterations: number, - keylen: number, - digest: string -): ArrayBuffer; +export function getPbkdf(password: ArrayLike, salt: ArrayLike, iterations: number, keylen: number, + digest: string): ArrayBuffer; // Keys export function exportKey(key: CryptoKey, options?: InnerExportOptions): KeyExportResult; @@ -226,21 +214,19 @@ export type KeyData = string | ArrayBuffer | ArrayBufferView; // DiffieHellman export class DiffieHellmanHandle { - public constructor( - sizeOrKey: number | ArrayBuffer | ArrayBufferView, - generator: number | ArrayBuffer | ArrayBufferView - ); - public setPublicKey(data: ArrayBuffer | ArrayBufferView | Buffer): void; - public setPrivateKey(data: ArrayBuffer | ArrayBufferView | Buffer): void; - public getPublicKey(): ArrayBuffer; - public getPrivateKey(): ArrayBuffer; - public getGenerator(): ArrayBuffer; - public getPrime(): ArrayBuffer; + public constructor(sizeOrKey: number | ArrayBuffer | ArrayBufferView, + generator: number | ArrayBuffer | ArrayBufferView); + public setPublicKey(data: ArrayBuffer | ArrayBufferView | Buffer): void; + public setPrivateKey(data: ArrayBuffer | ArrayBufferView | Buffer): void; + public getPublicKey(): ArrayBuffer; + public getPrivateKey(): ArrayBuffer; + public getGenerator(): ArrayBuffer; + public getPrime(): ArrayBuffer; - public computeSecret(key: ArrayBuffer | ArrayBufferView): ArrayBuffer; - public generateKeys(): ArrayBuffer; + public computeSecret(key: ArrayBuffer|ArrayBufferView): ArrayBuffer; + public generateKeys(): ArrayBuffer; - public getVerifyError(): number; + public getVerifyError(): number; } export function DiffieHellmanGroupHandle(name: string): DiffieHellmanHandle; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.ts index 12248fd6e..088a1d7db 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto.ts @@ -1,9 +1,10 @@ -import * as sjcl from "sjcl"; -import { Buffer } from "./internal_buffer"; +import * as sjcl from 'sjcl'; +import {Buffer} from "./internal_buffer"; -export type ArrayLike = ArrayBuffer | string | Buffer | ArrayBufferView; +export type ArrayLike = ArrayBuffer|string|Buffer|ArrayBufferView; export type KeyData = string | ArrayBuffer | ArrayBufferView; + /** * Checks if a number represented by an ArrayBufferView is prime. * @@ -36,16 +37,11 @@ export function checkPrimeSync(candidate: ArrayBufferView, num_checks: number): * @param {ArrayBufferView} [rem] - An ArrayBufferView representing a number to take the remainder of the generated prime number. * @returns {ArrayBuffer} - Returns an ArrayBuffer representing the generated prime number. */ -export function randomPrime( - size: number, - safe: boolean, - add?: ArrayBufferView, - rem?: ArrayBufferView -): ArrayBuffer { +export function randomPrime(size: number, safe: boolean, add?: ArrayBufferView, rem?: ArrayBufferView): ArrayBuffer { let prime: number; do { prime = sjcl.random.randomWords(1, 0)[0]; - prime = Math.abs(prime) % 2 ** size; + prime = Math.abs(prime) % (2 ** size); if (safe) { prime = 2 * prime + 1; } @@ -61,13 +57,7 @@ export function randomPrime( } // hkdf -export function getHkdf( - hash: string, - key: ArrayLike, - salt: ArrayLike, - info: ArrayLike, - length: number -): ArrayBuffer { +export function getHkdf(hash: string, key: ArrayLike, salt: ArrayLike, info: ArrayLike, length: number): ArrayBuffer { // Convert key, salt, and info to bitArrays let keyBits = sjcl.codec.utf8String.toBits(key.toString()); let saltBits = sjcl.codec.utf8String.toBits(salt.toString()); @@ -82,13 +72,7 @@ export function getHkdf( } // pbkdf2 -export function getPbkdf( - password: ArrayLike, - salt: ArrayLike, - iterations: number, - keylen: number, - digest: string -): ArrayBuffer { +export function getPbkdf(password: ArrayLike, salt: ArrayLike, iterations: number, keylen: number, digest: string): ArrayBuffer { // Convert password and salt to bitArrays let passwordBits = sjcl.codec.utf8String.toBits(password.toString()); let saltBits = sjcl.codec.utf8String.toBits(salt.toString()); @@ -101,18 +85,19 @@ export function getPbkdf( return sjcl.codec.arrayBuffer.fromBits(derivedKeyBits); } + export class HashHandle { private hash: sjcl.SjclHash; public constructor(algorithm: string, xofLen: number) { switch (algorithm) { - case "sha1": + case 'sha1': this.hash = new sjcl.hash.sha1(); break; - case "sha256": + case 'sha256': this.hash = new sjcl.hash.sha256(); break; - case "sha512": + case 'sha512': this.hash = new sjcl.hash.sha512(); break; default: @@ -136,23 +121,23 @@ export class HashHandle { } public copy(xofLen: number): HashHandle { - let algo = ""; + let algo =""; let hash = this.hash; switch (true) { case hash instanceof sjcl.hash.sha1: - algo = "sha1"; + algo = 'sha1'; break; case hash instanceof sjcl.hash.sha256: - algo = "sha256"; + algo = 'sha256'; break; case hash instanceof sjcl.hash.sha512: - algo = "sha512"; + algo = 'sha512'; break; default: throw new Error(`Unsupported hash algorithm: ${algo}`); } - let copy = new HashHandle(algo, xofLen); // Replace 'sha256' with the actual algorithm - copy.hash = this.hash; + let copy = new HashHandle( algo , xofLen); // Replace 'sha256' with the actual algorithm + copy.hash = this.hash return copy; } } @@ -163,13 +148,13 @@ export class HmacHandle { public constructor(algorithm: string, key: ArrayLike | CryptoKey) { let keyBits = sjcl.codec.utf8String.toBits(key.toString()); switch (algorithm) { - case "sha1": + case 'sha1': this.hmac = new sjcl.misc.hmac(keyBits, sjcl.hash.sha1); break; - case "sha256": + case 'sha256': this.hmac = new sjcl.misc.hmac(keyBits, sjcl.hash.sha256); break; - case "sha512": + case 'sha512': this.hmac = new sjcl.misc.hmac(keyBits, sjcl.hash.sha512); break; default: @@ -190,46 +175,45 @@ export class HmacHandle { } export interface RsaKeyAlgorithm { - name: "rsa" | "rsa-pss"; + name: 'rsa' | 'rsa-pss'; modulusLength: number; publicExponent: Uint8Array; hash?: string; } export interface EcKeyAlgorithm { - name: "ec"; + name: 'ec'; namedCurve: string; } export interface DhKeyAlgorithm { - name: "dh"; + name: 'dh'; prime: Uint8Array; generator: Uint8Array; } export interface DsaKeyAlgorithm { - name: "dsa"; + name: 'dsa'; prime: Uint8Array; divisorLength: number; } export interface HmacKeyAlgorithm { - name: "hmac"; + name: 'hmac'; hash: string; } export interface AesKeyAlgorithm { - name: "aes"; + name: 'aes'; length: number; } -export type KeyAlgorithm = - | RsaKeyAlgorithm - | EcKeyAlgorithm - | DhKeyAlgorithm - | DsaKeyAlgorithm - | HmacKeyAlgorithm - | AesKeyAlgorithm; +export type KeyAlgorithm = RsaKeyAlgorithm | + EcKeyAlgorithm | + DhKeyAlgorithm | + DsaKeyAlgorithm | + HmacKeyAlgorithm | + AesKeyAlgorithm; export interface CryptoKey { algorithm: KeyAlgorithm; @@ -270,17 +254,17 @@ export interface CryptoKeyPair { publicKey: CryptoKey; } -export type KeyObjectType = "secret" | "public" | "private"; +export type KeyObjectType = 'secret' | 'public' | 'private'; export type KeyExportResult = string | Buffer | JsonWebKey; -export type SecretKeyFormat = "buffer" | "jwk"; -export type AsymmetricKeyFormat = "pem" | "der" | "jwk"; -export type PublicKeyEncoding = "pkcs1" | "spki"; -export type PrivateKeyEncoding = "pkcs1" | "pkcs8" | "sec1"; -export type AsymmetricKeyType = "rsa" | "rsa-pss" | "dsa" | "ec" | "x25519" | "ed25519" | "dh"; -export type SecretKeyType = "hmac" | "aes"; -export type ParamEncoding = "named" | "explicit"; +export type SecretKeyFormat = 'buffer' | 'jwk'; +export type AsymmetricKeyFormat = 'pem' | 'der' | 'jwk'; +export type PublicKeyEncoding = 'pkcs1' | 'spki'; +export type PrivateKeyEncoding = 'pkcs1' | 'pkcs8' | 'sec1'; +export type AsymmetricKeyType = 'rsa' | 'rsa-pss' | 'dsa' | 'ec' | 'x25519' | 'ed25519' | 'dh'; +export type SecretKeyType = 'hmac' | 'aes'; +export type ParamEncoding = 'named' | 'explicit'; export interface SecretKeyExportOptions { format?: SecretKeyFormat; @@ -306,15 +290,13 @@ export interface InnerPrivateKeyExportOptions { passphrase?: Uint8Array; } -export type ExportOptions = - | SecretKeyExportOptions - | PublicKeyExportOptions - | PrivateKeyExportOptions; +export type ExportOptions = SecretKeyExportOptions | + PublicKeyExportOptions | + PrivateKeyExportOptions; -export type InnerExportOptions = - | SecretKeyExportOptions - | PublicKeyExportOptions - | InnerPrivateKeyExportOptions; +export type InnerExportOptions = SecretKeyExportOptions | + PublicKeyExportOptions | + InnerPrivateKeyExportOptions; export interface AsymmetricKeyDetails { modulusLength?: number; @@ -347,7 +329,7 @@ export interface GenerateKeyOptions { export interface GenerateKeyPairOptions { modulusLength?: number; - publicExponent?: number | bigint; + publicExponent?: number|bigint; hashAlgorithm?: string; mgf1HashAlgorithm?: string; saltLength?: number; @@ -396,12 +378,12 @@ export function createSecretKey(key: ArrayBuffer | ArrayBufferView): CryptoKey { return { algorithm: { - name: "aes", - length: key.byteLength * 8, + name: 'aes', + length: key.byteLength * 8 }, extractable: true, - type: "secret", - usages: ["encrypt", "decrypt"], + type: 'secret', + usages: ['encrypt', 'decrypt'] }; } @@ -415,16 +397,15 @@ export function createPublicKey(key: InnerCreateAsymmetricKeyOptions): CryptoKey throw new Error("Function createPublicKey is not implemented yet"); } + export class DiffieHellmanHandle { private prime: sjcl.BigNumber; private generator: sjcl.BigNumber; private privateKey: sjcl.BigNumber; private publicKey: sjcl.BigNumber; - public constructor( - sizeOrKey: number | ArrayBuffer | ArrayBufferView, - generator: number | ArrayBuffer | ArrayBufferView - ) { + public constructor(sizeOrKey: number | ArrayBuffer | ArrayBufferView, + generator: number | ArrayBuffer | ArrayBufferView) { // Convert sizeOrKey and generator to sjcl.bn this.prime = new sjcl.bn(sizeOrKey.toString()); this.generator = new sjcl.bn(generator.toString()); @@ -460,7 +441,7 @@ export class DiffieHellmanHandle { return sjcl.codec.arrayBuffer.fromBits(this.prime.toBits()); } - public computeSecret(key: ArrayBuffer | ArrayBufferView): ArrayBuffer { + public computeSecret(key: ArrayBuffer|ArrayBufferView): ArrayBuffer { let otherPublicKey = new sjcl.bn(key.toString()); let secret = otherPublicKey.powermod(this.privateKey, this.prime); return sjcl.codec.arrayBuffer.fromBits(secret.toBits()); @@ -468,7 +449,7 @@ export class DiffieHellmanHandle { public generateKeys(): ArrayBuffer { // Generate a new private key - this.privateKey = sjcl.bn.random(this.prime.sub(2), 10).add(1); + this.privateKey = sjcl.bn.random(this.prime.sub(2),10).add(1); // Calculate the new public key this.publicKey = this.generator.powermod(this.privateKey, this.prime); @@ -482,12 +463,13 @@ export class DiffieHellmanHandle { } } + export function DiffieHellmanGroupHandle(name: string): DiffieHellmanHandle { // Define some named groups with their prime and generator values - const groups: { [name: string]: { prime: number; generator: number } } = { - modp1: { prime: 2, generator: 2 }, - modp2: { prime: 3, generator: 2 }, - modp5: { prime: 5, generator: 2 }, + const groups: { [name: string]: { prime: number, generator: number } } = { + 'modp1': { prime: 2, generator: 2 }, + 'modp2': { prime: 3, generator: 2 }, + 'modp5': { prime: 5, generator: 2 }, // Add more named groups here }; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_dh.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_dh.ts index 762f512f9..1ce519c6d 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_dh.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_dh.ts @@ -1,198 +1,202 @@ + /* eslint-disable */ -"use strict"; +'use strict'; -import { Buffer } from "./internal_buffer"; +import { + Buffer, +} from './internal_buffer'; -import * as cryptoImpl from "./crypto"; +import * as cryptoImpl from './crypto'; type ArrayLike = cryptoImpl.ArrayLike; -import { ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY, ERR_INVALID_ARG_TYPE } from "./internal_errors"; +import { + ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY, + ERR_INVALID_ARG_TYPE, +} from './internal_errors'; -import { validateInt32 } from "./validators"; +import { + validateInt32, +} from './validators'; -import { isArrayBufferView, isAnyArrayBuffer } from "./internal_types"; +import { + isArrayBufferView, + isAnyArrayBuffer +} from './internal_types'; -import { getArrayBufferOrView, toBuf, kHandle } from "./crypto_util"; +import { + getArrayBufferOrView, + toBuf, + kHandle, +} from './crypto_util'; const DH_GENERATOR = 2; interface DiffieHellman { - [kHandle]: cryptoImpl.DiffieHellmanHandle; + [kHandle]: cryptoImpl.DiffieHellmanHandle; } -let DiffieHellman = function ( - this: DiffieHellman, - sizeOrKey: number | ArrayLike, - keyEncoding?: number | string, - generator?: number | ArrayLike, - genEncoding?: string -): DiffieHellman { - if (!(this instanceof DiffieHellman)) - return new DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding); - if ( - typeof sizeOrKey !== "number" && - typeof sizeOrKey !== "string" && +let DiffieHellman = function (this: DiffieHellman, sizeOrKey: number|ArrayLike, + keyEncoding?: number|string, generator?: number|ArrayLike, + genEncoding?: string): DiffieHellman { + if (!(this instanceof DiffieHellman)) + return new DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding); + if (typeof sizeOrKey !== 'number' && + typeof sizeOrKey !== 'string' && !isArrayBufferView(sizeOrKey) && - !isAnyArrayBuffer(sizeOrKey) - ) { - throw new ERR_INVALID_ARG_TYPE( - "sizeOrKey", - ["number", "string", "ArrayBuffer", "Buffer", "TypedArray", "DataView"], - sizeOrKey - ); - } - - // Sizes < 0 don't make sense but they _are_ accepted (and subsequently - // rejected with ERR_OSSL_BN_BITS_TOO_SMALL) by OpenSSL. The glue code - // in node_crypto.cc accepts values that are IsInt32() for that reason - // and that's why we do that here too. - if (typeof sizeOrKey === "number") validateInt32(sizeOrKey, "sizeOrKey"); - - if (keyEncoding && !Buffer.isEncoding(keyEncoding) && keyEncoding !== "buffer") { - genEncoding = generator as any; - generator = keyEncoding; - keyEncoding = "utf-8"; // default encoding - } - - keyEncoding ??= "utf-8"; - genEncoding ??= "utf-8"; - - if (typeof sizeOrKey !== "number") sizeOrKey = toBuf(sizeOrKey, keyEncoding as string); - - if (!generator) { - generator = DH_GENERATOR; - } else if (typeof generator === "number") { - validateInt32(generator, "generator"); - } else if (typeof generator === "string") { - generator = toBuf(generator, genEncoding); - } else if (!isArrayBufferView(generator) && !isAnyArrayBuffer(generator)) { - throw new ERR_INVALID_ARG_TYPE( - "generator", - ["number", "string", "ArrayBuffer", "Buffer", "TypedArray", "DataView"], - generator - ); - } - - this[kHandle] = new cryptoImpl.DiffieHellmanHandle(sizeOrKey as any, generator as any); - Object.defineProperty(DiffieHellman.prototype, "verifyError", { - get: function () { - return this[kHandle].getVerifyError(); - }, - configurable: true, - enumerable: true, - }); - return this; -} as any as { - new ( - sizeOrKey: number | ArrayLike, - keyEncoding?: number | string, - generator?: number | ArrayLike, - genEncoding?: string - ): DiffieHellman; -}; + !isAnyArrayBuffer(sizeOrKey)) { + throw new ERR_INVALID_ARG_TYPE( + 'sizeOrKey', + ['number', 'string', 'ArrayBuffer', 'Buffer', 'TypedArray', 'DataView'], + sizeOrKey, + ); + } + + // Sizes < 0 don't make sense but they _are_ accepted (and subsequently + // rejected with ERR_OSSL_BN_BITS_TOO_SMALL) by OpenSSL. The glue code + // in node_crypto.cc accepts values that are IsInt32() for that reason + // and that's why we do that here too. + if (typeof sizeOrKey === 'number') + validateInt32(sizeOrKey, 'sizeOrKey'); + + if (keyEncoding && !Buffer.isEncoding(keyEncoding) && keyEncoding !== 'buffer') { + genEncoding = generator as any; + generator = keyEncoding; + keyEncoding = "utf-8"; // default encoding + } + + keyEncoding ??= 'utf-8'; + genEncoding ??= 'utf-8'; + + if (typeof sizeOrKey !== 'number') + sizeOrKey = toBuf(sizeOrKey, keyEncoding as string); + + if (!generator) { + generator = DH_GENERATOR; + } else if (typeof generator === 'number') { + validateInt32(generator, 'generator'); + } else if (typeof generator === 'string') { + generator = toBuf(generator, genEncoding); + } else if (!isArrayBufferView(generator) && !isAnyArrayBuffer(generator)) { + throw new ERR_INVALID_ARG_TYPE( + 'generator', + ['number', 'string', 'ArrayBuffer', 'Buffer', 'TypedArray', 'DataView'], + generator, + ); + } + + this[kHandle] = new cryptoImpl.DiffieHellmanHandle(sizeOrKey as any, generator as any); + Object.defineProperty(DiffieHellman.prototype, "verifyError", { + get: function () { + return this[kHandle].getVerifyError(); + }, + configurable: true, + enumerable: true, + }); + return this; +} as any as { new (sizeOrKey: number|ArrayLike, keyEncoding?: number|string, + generator?: number|ArrayLike, genEncoding?: string): DiffieHellman; }; interface DiffieHellmanGroup { - [kHandle]: cryptoImpl.DiffieHellmanHandle; + [kHandle]: cryptoImpl.DiffieHellmanHandle; } -let DiffieHellmanGroup = function (this: DiffieHellmanGroup, name: string): DiffieHellmanGroup { - if (!(this instanceof DiffieHellmanGroup)) return new DiffieHellmanGroup(name); - - // The C++-based handle is shared between both classes, so DiffieHellmanGroupHandle() is merely - // a different constructor for a DiffieHellmanHandle. - this[kHandle] = cryptoImpl.DiffieHellmanGroupHandle(name); - Object.defineProperty(DiffieHellmanGroup.prototype, "verifyError", { - get: function () { - return this[kHandle].getVerifyError(); - }, - configurable: true, - enumerable: true, - }); - return this; -} as any as { new (name: string): DiffieHellmanGroup }; - -DiffieHellmanGroup.prototype.generateKeys = DiffieHellman.prototype.generateKeys = dhGenerateKeys; +let DiffieHellmanGroup = function(this: DiffieHellmanGroup, name: string): DiffieHellmanGroup { + if (!(this instanceof DiffieHellmanGroup)) + return new DiffieHellmanGroup(name); + + // The C++-based handle is shared between both classes, so DiffieHellmanGroupHandle() is merely + // a different constructor for a DiffieHellmanHandle. + this[kHandle] = cryptoImpl.DiffieHellmanGroupHandle(name); + Object.defineProperty(DiffieHellmanGroup.prototype, "verifyError", { + get: function () { + return this[kHandle].getVerifyError(); + }, + configurable: true, + enumerable: true, + }); + return this; +} as any as { new (name: string): DiffieHellmanGroup; }; + +DiffieHellmanGroup.prototype.generateKeys = DiffieHellman.prototype.generateKeys = + dhGenerateKeys; DiffieHellmanGroup.prototype.computeSecret = DiffieHellman.prototype.computeSecret = - dhComputeSecret; + dhComputeSecret; DiffieHellmanGroup.prototype.getPrime = DiffieHellman.prototype.getPrime = dhGetPrime; -DiffieHellmanGroup.prototype.getGenerator = DiffieHellman.prototype.getGenerator = dhGetGenerator; -DiffieHellmanGroup.prototype.getPublicKey = DiffieHellman.prototype.getPublicKey = dhGetPublicKey; +DiffieHellmanGroup.prototype.getGenerator = DiffieHellman.prototype.getGenerator = + dhGetGenerator; +DiffieHellmanGroup.prototype.getPublicKey = DiffieHellman.prototype.getPublicKey = + dhGetPublicKey; DiffieHellmanGroup.prototype.getPrivateKey = DiffieHellman.prototype.getPrivateKey = - dhGetPrivateKey; + dhGetPrivateKey; DiffieHellman.prototype.setPublicKey = dhSetPublicKey; DiffieHellman.prototype.setPrivateKey = dhSetPrivateKey; -export { DiffieHellman, DiffieHellmanGroup }; +export {DiffieHellman, DiffieHellmanGroup}; -type DHLike = DiffieHellman | DiffieHellmanGroup; -function dhGenerateKeys(this: DHLike, encoding?: string): Buffer | string { - const keys = this[kHandle].generateKeys(); - return encode(keys, encoding); +type DHLike = DiffieHellman|DiffieHellmanGroup; +function dhGenerateKeys(this: DHLike, encoding?: string): Buffer|string { + const keys = this[kHandle].generateKeys(); + return encode(keys, encoding); } -function dhComputeSecret( - this: DHLike, - key: ArrayLike, - inEnc?: string, - outEnc?: string -): Buffer | string { - key = getArrayBufferOrView(key, "key", inEnc); - const ret = this[kHandle].computeSecret(key); - if (typeof ret === "string") throw new ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY(); - return encode(ret, outEnc); +function dhComputeSecret(this: DHLike, key: ArrayLike, inEnc?: string, + outEnc?: string): Buffer|string { + key = getArrayBufferOrView(key, 'key', inEnc); + const ret = this[kHandle].computeSecret(key); + if (typeof ret === 'string') + throw new ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY(); + return encode(ret, outEnc); } -function dhGetPrime(this: DHLike, encoding?: string): Buffer | string { - const prime = this[kHandle].getPrime(); - return encode(prime, encoding); +function dhGetPrime(this: DHLike, encoding?: string): Buffer|string { + const prime = this[kHandle].getPrime(); + return encode(prime, encoding); } -function dhGetGenerator(this: DHLike, encoding?: string): Buffer | string { - const generator = this[kHandle].getGenerator(); - return encode(generator, encoding); +function dhGetGenerator(this: DHLike, encoding?: string): Buffer|string { + const generator = this[kHandle].getGenerator(); + return encode(generator, encoding); } -function dhGetPublicKey(this: DHLike, encoding?: string): Buffer | string { - const key = this[kHandle].getPublicKey(); - return encode(key, encoding); +function dhGetPublicKey(this: DHLike, encoding?: string): Buffer|string { + const key = this[kHandle].getPublicKey(); + return encode(key, encoding); } -function dhGetPrivateKey(this: DHLike, encoding?: string): Buffer | string { - const key = this[kHandle].getPrivateKey(); - return encode(key, encoding); +function dhGetPrivateKey(this: DHLike, encoding?: string): Buffer|string { + const key = this[kHandle].getPrivateKey(); + return encode(key, encoding); } function dhSetPublicKey(this: DiffieHellman, key: ArrayLike, encoding?: string): DiffieHellman { - key = getArrayBufferOrView(key, "key", encoding); - this[kHandle].setPublicKey(key); - return this; + key = getArrayBufferOrView(key, 'key', encoding); + this[kHandle].setPublicKey(key); + return this; } function dhSetPrivateKey(this: DiffieHellman, key: ArrayLike, encoding?: string): DiffieHellman { - key = getArrayBufferOrView(key, "key", encoding); - this[kHandle].setPrivateKey(key); - return this; + key = getArrayBufferOrView(key, 'key', encoding); + this[kHandle].setPrivateKey(key); + return this; } -function encode(buffer: ArrayBuffer, encoding?: string): Buffer | string { - if (encoding && encoding !== "buffer") return Buffer.from(buffer).toString(encoding); - return Buffer.from(buffer); +function encode(buffer: ArrayBuffer, encoding?: string): Buffer|string { + if (encoding && encoding !== 'buffer') + return Buffer.from(buffer).toString(encoding); + return Buffer.from(buffer); } -export function createDiffieHellman( - sizeOrKey: number | ArrayLike, - keyEncoding?: number | string, - generator?: number | ArrayLike, - genEncoding?: string -): DiffieHellman { - return new DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding); +export function createDiffieHellman(sizeOrKey: number|ArrayLike, + keyEncoding?: number|string, generator?: number|ArrayLike, + genEncoding?: string): DiffieHellman { + return new DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding); } export function createDiffieHellmanGroup(name: string): DiffieHellmanGroup { - return new DiffieHellmanGroup(name); + return new DiffieHellmanGroup(name); } export function getDiffieHellman(name: string): DiffieHellmanGroup { - return createDiffieHellmanGroup(name); + return createDiffieHellmanGroup(name); } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hash.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hash.ts index 296bd2013..160fd63a6 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hash.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hash.ts @@ -1,230 +1,235 @@ /* eslint-disable */ -import * as cryptoImpl from "./crypto"; +import * as cryptoImpl from './crypto'; type ArrayLike = cryptoImpl.ArrayLike; -import { kFinalized, kHandle, kState, getArrayBufferOrView, getStringOption } from "./crypto_util"; +import { + kFinalized, + kHandle, + kState, + getArrayBufferOrView, + getStringOption, +} from './crypto_util'; -import { Buffer } from "./internal_buffer"; +import { + Buffer +} from './internal_buffer'; import { - ERR_CRYPTO_HASH_FINALIZED, - ERR_CRYPTO_HASH_UPDATE_FAILED, - ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE, - ERR_INVALID_ARG_TYPE, -} from "./internal_errors"; + ERR_CRYPTO_HASH_FINALIZED, + ERR_CRYPTO_HASH_UPDATE_FAILED, + ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE, + ERR_INVALID_ARG_TYPE, +} from './internal_errors'; -import { validateEncoding, validateString, validateUint32 } from "./validators"; +import { + validateEncoding, + validateString, + validateUint32, +} from './validators'; -import { normalizeEncoding } from "./internal_utils"; +import { + normalizeEncoding +} from './internal_utils'; -import { isArrayBufferView, isCryptoKey, isAnyArrayBuffer } from "./internal_types"; +import { + isArrayBufferView, + isCryptoKey, + isAnyArrayBuffer, +} from './internal_types'; -import { Transform, TransformOptions, TransformCallback } from "./streams_transform"; +import { + Transform, + TransformOptions, + TransformCallback, +} from './streams_transform'; -import { KeyObject } from "./crypto_keys"; +import { + KeyObject, +} from './crypto_keys'; export interface HashOptions extends TransformOptions { - outputLength?: number; + outputLength?: number; } interface _kState { - [kFinalized]: boolean; + [kFinalized]: boolean; } interface Hash extends Transform { - [kHandle]: cryptoImpl.HashHandle; - [kState]: _kState; + [kHandle]: cryptoImpl.HashHandle; + [kState]: _kState; } // These helper functions are needed because the constructors can // use new, in which case V8 cannot inline the recursive constructor call export function createHash(algorithm: string, options?: HashOptions): Hash { - return new Hash(algorithm, options); + return new Hash(algorithm, options); } -let Hash = function ( - this: Hash, - algorithm: string | cryptoImpl.HashHandle, - options?: HashOptions -): Hash { - if (!(this instanceof Hash)) return new Hash(algorithm, options); - - const xofLen = typeof options === "object" ? options.outputLength : undefined; - if (xofLen !== undefined) validateUint32(xofLen, "options.outputLength"); - if (algorithm instanceof cryptoImpl.HashHandle) { - this[kHandle] = algorithm.copy(xofLen as number); - } else { - validateString(algorithm, "algorithm"); - this[kHandle] = new cryptoImpl.HashHandle(algorithm, xofLen as number); - } - this[kState] = { - [kFinalized]: false, - }; +let Hash = function(this: Hash, algorithm: string | cryptoImpl.HashHandle, + options?: HashOptions): Hash { + if (!(this instanceof Hash)) + return new Hash(algorithm, options); - Transform.call(this, options); - return this; -} as any as { new (algorithm: string | cryptoImpl.HashHandle, options?: HashOptions): Hash }; + const xofLen = typeof options === 'object' ? options.outputLength : undefined; + if (xofLen !== undefined) + validateUint32(xofLen, 'options.outputLength'); + if (algorithm instanceof cryptoImpl.HashHandle) { + this[kHandle] = algorithm.copy(xofLen as number); + } else { + validateString(algorithm, 'algorithm'); + this[kHandle] = new cryptoImpl.HashHandle(algorithm, xofLen as number); + } + this[kState] = { + [kFinalized]: false, + }; + + Transform.call(this, options); + return this; +} as any as { new (algorithm: string | cryptoImpl.HashHandle, options?: HashOptions): Hash; }; Object.setPrototypeOf(Hash.prototype, Transform.prototype); Object.setPrototypeOf(Hash, Transform); -Hash.prototype.copy = function (this: Hash, options?: HashOptions): Hash { - const state = this[kState]; - if (state[kFinalized]) throw new ERR_CRYPTO_HASH_FINALIZED(); - - return new Hash(this[kHandle], options); -}; - -Hash.prototype._transform = function ( - this: Hash | Hmac, - chunk: string | Buffer | ArrayBufferView, - encoding: string, - callback: TransformCallback -): void { - if (typeof chunk === "string") { - encoding ??= "utf-8"; - validateEncoding(chunk, encoding); - encoding = normalizeEncoding(encoding)!; - chunk = Buffer.from(chunk, encoding); - } - this[kHandle].update(chunk); - callback(); -}; +Hash.prototype.copy = function(this: Hash, options?: HashOptions): Hash { + const state = this[kState]; + if (state[kFinalized]) + throw new ERR_CRYPTO_HASH_FINALIZED(); -Hash.prototype._flush = function (this: Hash | Hmac, callback: TransformCallback): void { - this.push(Buffer.from(this[kHandle].digest())); - callback(); -}; + return new Hash(this[kHandle], options); +} -Hash.prototype.update = function ( - this: Hash | Hmac, - data: string | Buffer | ArrayBufferView, - encoding?: string -): Hash | Hmac { - encoding ??= "utf8"; - if (encoding === "buffer") { - encoding = undefined; - } +Hash.prototype._transform = function(this: Hash | Hmac, chunk: string | Buffer | ArrayBufferView, + encoding: string, callback: TransformCallback): void { + if (typeof chunk === 'string') { + encoding ??= 'utf-8'; + validateEncoding(chunk, encoding); + encoding = normalizeEncoding(encoding)!; + chunk = Buffer.from(chunk, encoding); + } + this[kHandle].update(chunk); + callback(); +} - const state = this[kState]; - if (state[kFinalized]) throw new ERR_CRYPTO_HASH_FINALIZED(); - - if (typeof data === "string") { - validateEncoding(data, encoding!); - encoding = normalizeEncoding(encoding); - data = Buffer.from(data, encoding); - } else if (!isArrayBufferView(data)) { - throw new ERR_INVALID_ARG_TYPE( - "data", - ["string", "Buffer", "TypedArray", "DataView"], - data - ); - } +Hash.prototype._flush = function(this: Hash | Hmac, callback: TransformCallback): void { + this.push(Buffer.from(this[kHandle].digest())); + callback(); +} - if (!this[kHandle].update(data)) throw new ERR_CRYPTO_HASH_UPDATE_FAILED(); - return this; -}; +Hash.prototype.update = function(this: Hash | Hmac, data: string | Buffer | ArrayBufferView, + encoding?: string): Hash | Hmac { + encoding ??= 'utf8'; + if (encoding === 'buffer') { + encoding = undefined; + } + + const state = this[kState]; + if (state[kFinalized]) + throw new ERR_CRYPTO_HASH_FINALIZED(); + + if (typeof data === 'string') { + validateEncoding(data, encoding!); + encoding = normalizeEncoding(encoding); + data = Buffer.from(data, encoding); + } else if (!isArrayBufferView(data)) { + throw new ERR_INVALID_ARG_TYPE( + 'data', ['string', 'Buffer', 'TypedArray', 'DataView'], data); + } + + if (!this[kHandle].update(data)) + throw new ERR_CRYPTO_HASH_UPDATE_FAILED(); + return this; +} -Hash.prototype.digest = function (this: Hash, outputEncoding?: string): Buffer | string { - const state = this[kState]; - if (state[kFinalized]) throw new ERR_CRYPTO_HASH_FINALIZED(); - - // Explicit conversion for backward compatibility. - const ret = Buffer.from(this[kHandle].digest()); - state[kFinalized] = true; - if (outputEncoding !== undefined && outputEncoding !== "buffer") { - return ret.toString(outputEncoding); - } else { - return ret; - } -}; +Hash.prototype.digest = function(this: Hash, outputEncoding?: string): Buffer | string { + const state = this[kState]; + if (state[kFinalized]) + throw new ERR_CRYPTO_HASH_FINALIZED(); + + // Explicit conversion for backward compatibility. + const ret = Buffer.from(this[kHandle].digest()); + state[kFinalized] = true; + if (outputEncoding !== undefined && outputEncoding !== 'buffer') { + return ret.toString(outputEncoding); + } else { + return ret; + } +} /////////////////////////// interface Hmac extends Transform { - [kHandle]: cryptoImpl.HmacHandle; - [kState]: _kState; + [kHandle]: cryptoImpl.HmacHandle; + [kState]: _kState; } -export function createHmac( - hmac: string, - key: ArrayLike | KeyObject | CryptoKey, - options?: TransformOptions -): Hmac { - return new Hmac(hmac, key, options); +export function createHmac(hmac: string, key: ArrayLike | KeyObject | CryptoKey, + options?: TransformOptions): Hmac { + return new Hmac(hmac, key, options); } -let Hmac = function ( - this: Hmac, - hmac: string, - key: ArrayLike | KeyObject | cryptoImpl.CryptoKey, - options?: TransformOptions -): Hmac { - if (!(this instanceof Hmac)) { - return new Hmac(hmac, key, options); +let Hmac = function(this: Hmac, hmac: string, key: ArrayLike | KeyObject | cryptoImpl.CryptoKey, + options?: TransformOptions): Hmac { + if (!(this instanceof Hmac)) { + return new Hmac(hmac, key, options); + } + validateString(hmac, 'hmac'); + const encoding = getStringOption(options, 'encoding'); + + if (key instanceof KeyObject) { + if (key.type !== 'secret') { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, 'secret'); } - validateString(hmac, "hmac"); - const encoding = getStringOption(options, "encoding"); - - if (key instanceof KeyObject) { - if (key.type !== "secret") { - throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "secret"); - } - this[kHandle] = new cryptoImpl.HmacHandle(hmac, key[kHandle]); - } else if (isCryptoKey(key)) { - if ((key as cryptoImpl.CryptoKey).type !== "secret") { - throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE( - (key as cryptoImpl.CryptoKey).type, - "secret" - ); - } - this[kHandle] = new cryptoImpl.HmacHandle(hmac, key); - } else if (typeof key !== "string" && !isArrayBufferView(key) && !isAnyArrayBuffer(key)) { - throw new ERR_INVALID_ARG_TYPE( - "key", - ["ArrayBuffer", "Buffer", "ArrayBufferView", "string", "KeyObject", "CryptoKey"], - key - ); - } else { - this[kHandle] = new cryptoImpl.HmacHandle( - hmac, - getArrayBufferOrView(key as ArrayLike, "key", encoding) - ); + this[kHandle] = new cryptoImpl.HmacHandle(hmac, key[kHandle]); + } else if (isCryptoKey(key)) { + if ((key as cryptoImpl.CryptoKey).type !== 'secret') { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE((key as cryptoImpl.CryptoKey).type, 'secret'); } - - this[kState] = { - [kFinalized]: false, - }; - Transform.call(this, options); - return this; -} as any as { - new (hmac: string, key: ArrayLike | KeyObject | CryptoKey, options?: TransformOptions): Hmac; -}; + this[kHandle] = new cryptoImpl.HmacHandle(hmac, key); + } else if (typeof key !== 'string' && + !isArrayBufferView(key) && + !isAnyArrayBuffer(key)) { + throw new ERR_INVALID_ARG_TYPE( + 'key', + [ 'ArrayBuffer', 'Buffer', 'ArrayBufferView', 'string', 'KeyObject', 'CryptoKey'], + key); + } else { + this[kHandle] = new cryptoImpl.HmacHandle(hmac, getArrayBufferOrView(key as ArrayLike, + 'key', encoding)); + } + + this[kState] = { + [kFinalized]: false, + }; + Transform.call(this, options); + return this; +} as any as { new (hmac: string, key: ArrayLike | KeyObject | CryptoKey, + options?: TransformOptions): Hmac; }; Object.setPrototypeOf(Hmac.prototype, Transform.prototype); Object.setPrototypeOf(Hmac, Transform); Hmac.prototype.update = Hash.prototype.update; -Hmac.prototype.digest = function (this: Hmac, outputEncoding?: string): Buffer | string { - const state = this[kState]; - if (state[kFinalized]) { - const buf = Buffer.from(""); - return outputEncoding === "buffer" ? buf : buf.toString(outputEncoding); - } - - // Explicit conversion for backward compatibility. - const ret = Buffer.from(this[kHandle].digest()); - state[kFinalized] = true; - if (outputEncoding !== undefined && outputEncoding !== "buffer") { - return ret.toString(outputEncoding); - } else { - return ret; - } +Hmac.prototype.digest = function(this: Hmac, outputEncoding?: string): Buffer | string { + const state = this[kState]; + if (state[kFinalized]) { + const buf = Buffer.from(''); + return outputEncoding === 'buffer' ? buf : buf.toString(outputEncoding); + } + + // Explicit conversion for backward compatibility. + const ret = Buffer.from(this[kHandle].digest()); + state[kFinalized] = true; + if (outputEncoding !== undefined && outputEncoding !== 'buffer') { + return ret.toString(outputEncoding); + } else { + return ret; + } }; Hmac.prototype._flush = Hash.prototype._flush; Hmac.prototype._transform = Hash.prototype._transform; -export { Hash, Hmac }; +export {Hash, Hmac}; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hkdf.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hkdf.ts index 7196bea89..3c48a2849 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hkdf.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_hkdf.ts @@ -1,110 +1,124 @@ /* eslint-disable */ -"use strict"; +'use strict'; -import * as cryptoImpl from "./crypto"; +import * as cryptoImpl from './crypto'; -import { validateFunction, validateInteger, validateString } from "./validators"; +import { + validateFunction, + validateInteger, + validateString, +} from './validators'; -import { KeyObject } from "./crypto_keys"; +import { + KeyObject, +} from './crypto_keys'; type ArrayLike = cryptoImpl.ArrayLike; -import { kMaxLength } from "./internal_buffer"; - -import { toBuf, validateByteSource } from "./crypto_util"; - -import { isAnyArrayBuffer, isArrayBufferView } from "./internal_types"; - -import { NodeError, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } from "./internal_errors"; - -function validateParameters( - hash: string, - key: ArrayLike | KeyObject, - salt: ArrayLike, - info: ArrayLike, - length: number -) { - // TODO(soon): Add support for KeyObject input. - if (key instanceof KeyObject) { - throw new NodeError( - "ERR_METHOD_NOT_IMPLEMENTED", - "KeyObject support for hkdf() and " + - "hkdfSync() is not yet implemented. Use ArrayBuffer, TypedArray, " + - "DataView, or Buffer instead." - ); - } - - validateString(hash, "digest"); - key = prepareKey(key as unknown as ArrayLike); - salt = validateByteSource(salt, "salt"); - info = validateByteSource(info, "info"); - - validateInteger(length, "length", 0, kMaxLength); - - if (info.byteLength > 1024) { - throw new ERR_OUT_OF_RANGE( - "info", - "must not contain more than 1024 bytes", - info.byteLength - ); - } - - return { - hash, - key, - salt, - info, - length, - }; +import { + kMaxLength, +} from './internal_buffer'; + +import { + toBuf, + validateByteSource, +} from './crypto_util'; + +import { + isAnyArrayBuffer, + isArrayBufferView, +} from './internal_types'; + +import { + NodeError, + ERR_INVALID_ARG_TYPE, + ERR_OUT_OF_RANGE, +} from './internal_errors'; + +function validateParameters(hash: string, key: ArrayLike | KeyObject, salt: ArrayLike, + info: ArrayLike, length: number) { + // TODO(soon): Add support for KeyObject input. + if (key instanceof KeyObject) { + throw new NodeError("ERR_METHOD_NOT_IMPLEMENTED", "KeyObject support for hkdf() and " + + "hkdfSync() is not yet implemented. Use ArrayBuffer, TypedArray, " + + "DataView, or Buffer instead."); + } + + validateString(hash, 'digest'); + key = prepareKey(key as unknown as ArrayLike); + salt = validateByteSource(salt, 'salt'); + info = validateByteSource(info, 'info'); + + validateInteger(length, 'length', 0, kMaxLength); + + if (info.byteLength > 1024) { + throw new ERR_OUT_OF_RANGE( + 'info', + 'must not contain more than 1024 bytes', + info.byteLength); + } + + return { + hash, + key, + salt, + info, + length, + }; } function prepareKey(key: ArrayLike): ArrayLike { - key = toBuf(key); - - if (!isAnyArrayBuffer(key) && !isArrayBufferView(key)) { - throw new ERR_INVALID_ARG_TYPE( - "ikm", - ["string", "SecretKeyObject", "ArrayBuffer", "TypedArray", "DataView", "Buffer"], - key - ); - } - - return key; + key = toBuf(key); + + if (!isAnyArrayBuffer(key) && !isArrayBufferView(key)) { + throw new ERR_INVALID_ARG_TYPE( + 'ikm', + [ + 'string', + 'SecretKeyObject', + 'ArrayBuffer', + 'TypedArray', + 'DataView', + 'Buffer', + ], + key); + } + + return key; } -export function hkdf( - hash: string, - key: ArrayLike | KeyObject, - salt: ArrayLike, - info: ArrayLike, - length: number, - callback: (err: Error | null, derivedKey?: ArrayBuffer) => void -): void { - ({ hash, key, salt, info, length } = validateParameters(hash, key, salt, info, length)); - - validateFunction(callback, "callback"); - - new Promise((res, rej) => { - try { - res(cryptoImpl.getHkdf(hash, key as ArrayLike, salt, info, length)); - } catch (err) { - rej(err); - } - }).then( - (val: ArrayBuffer) => callback(null, val), - (err) => callback(err) - ); +export function hkdf(hash: string, key: ArrayLike | KeyObject, salt: ArrayLike, info: ArrayLike, + length: number, + callback: (err: Error|null, derivedKey?: ArrayBuffer) => void): void { + ({ + hash, + key, + salt, + info, + length, + } = validateParameters(hash, key, salt, info, length)); + + validateFunction(callback, 'callback'); + + new Promise((res, rej) => { + try { + res(cryptoImpl.getHkdf(hash, key as ArrayLike, salt, info, length)); + } catch(err) { + rej(err); + } + }).then((val: ArrayBuffer) => callback(null, val), (err) => callback(err)); } -export function hkdfSync( - hash: string, - key: ArrayLike | KeyObject, - salt: ArrayLike, - info: ArrayLike, - length: number -): ArrayBuffer { - ({ hash, key, salt, info, length } = validateParameters(hash, key, salt, info, length)); - - return cryptoImpl.getHkdf(hash, key, salt, info, length); +export function hkdfSync(hash: string, key: ArrayLike | KeyObject, salt: ArrayLike, + info: ArrayLike, length: number): ArrayBuffer { + ({ + hash, + key, + salt, + info, + length, + } = validateParameters(hash, key, salt, info, length)); + + return cryptoImpl.getHkdf(hash, key, salt, info, length); } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_keys.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_keys.ts index 488d7b8d6..aa549f57d 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_keys.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_keys.ts @@ -1,220 +1,205 @@ /* eslint-disable */ -import { Buffer } from "./internal_buffer"; - -import * as cryptoImpl from "./crypto"; - -const { - CryptoKey, - KeyData, - KeyObjectType, - KeyExportResult, - SecretKeyType, - SecretKeyExportOptions, - PublicKeyExportOptions, - PrivateKeyExportOptions, - ExportOptions, - AsymmetricKeyDetails, - AsymmetricKeyType, - CreateAsymmetricKeyOptions, - GenerateKeyOptions, - GenerateKeyPairOptions, - InnerExportOptions, - // TODO(soon): Uncomment these once createPrivateKey/createPublicKey are implemented. - // JsonWebKey, - // InnerCreateAsymmetricKeyOptions, -} = cryptoImpl; - -import { arrayBufferToUnsignedBigInt, kHandle } from "./crypto_util"; +import { Buffer } from './internal_buffer'; + +import * as cryptoImpl from './crypto'; + +const +{ + CryptoKey, + KeyData, + KeyObjectType, + KeyExportResult, + SecretKeyType, + SecretKeyExportOptions, + PublicKeyExportOptions, + PrivateKeyExportOptions, + ExportOptions, + AsymmetricKeyDetails, + AsymmetricKeyType, + CreateAsymmetricKeyOptions, + GenerateKeyOptions, + GenerateKeyPairOptions, + InnerExportOptions, + // TODO(soon): Uncomment these once createPrivateKey/createPublicKey are implemented. + // JsonWebKey, + // InnerCreateAsymmetricKeyOptions, +} + = cryptoImpl; + + import { - isAnyArrayBuffer, - isArrayBuffer, - isArrayBufferView, - isUint8Array, - // TODO(soon): Uncomment these once createPrivateKey/createPublicKey are implemented. - // isSharedArrayBuffer, -} from "./internal_types"; + arrayBufferToUnsignedBigInt, + kHandle, +} from './crypto_util'; import { - ERR_INVALID_ARG_TYPE, - ERR_METHOD_NOT_IMPLEMENTED, - // TODO(soon): Uncomment these once createPrivateKey/createPublicKey are implemented. - // ERR_INVALID_ARG_VALUE, -} from "./internal_errors"; + isAnyArrayBuffer, + isArrayBuffer, + isArrayBufferView, + isUint8Array, + // TODO(soon): Uncomment these once createPrivateKey/createPublicKey are implemented. + // isSharedArrayBuffer, +} from './internal_types'; -import { validateObject, validateString } from "./validators"; +import { + ERR_INVALID_ARG_TYPE, + ERR_METHOD_NOT_IMPLEMENTED, + // TODO(soon): Uncomment these once createPrivateKey/createPublicKey are implemented. + // ERR_INVALID_ARG_VALUE, +} from './internal_errors'; -export abstract class KeyObject { - [kHandle]: CryptoKey; +import { + validateObject, + validateString, +} from './validators'; - constructor() { - // KeyObjects cannot be created with new ... use one of the - // create or generate methods, or use from to get from a - // CryptoKey. - throw new Error("Illegal constructor"); +export abstract class KeyObject { + [kHandle]: CryptoKey; + + constructor() { + // KeyObjects cannot be created with new ... use one of the + // create or generate methods, or use from to get from a + // CryptoKey. + throw new Error('Illegal constructor'); + } + + static from(key: CryptoKey) : KeyObject { + if (!(key instanceof CryptoKey)) { + throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key); } - - static from(key: CryptoKey): KeyObject { - if (!(key instanceof CryptoKey)) { - throw new ERR_INVALID_ARG_TYPE("key", "CryptoKey", key); - } - switch (key.type) { - case "secret": - return Reflect.construct( - function (this: SecretKeyObject) { - this[kHandle] = key; - }, - [], - SecretKeyObject - ); - case "private": - return Reflect.construct( - function (this: PrivateKeyObject) { - this[kHandle] = key; - }, - [], - PrivateKeyObject - ); - case "public": - return Reflect.construct( - function (this: PublicKeyObject) { - this[kHandle] = key; - }, - [], - PublicKeyObject - ); - } + switch (key.type) { + case 'secret': + return Reflect.construct(function(this: SecretKeyObject) { + this[kHandle] = key; + }, [], SecretKeyObject); + case 'private': + return Reflect.construct(function(this: PrivateKeyObject) { + this[kHandle] = key; + }, [], PrivateKeyObject); + case 'public': + return Reflect.construct(function(this: PublicKeyObject) { + this[kHandle] = key; + }, [], PublicKeyObject); } - - export(options: ExportOptions = {}): KeyExportResult { - validateObject(options, "options", {}); - - // Yes, converting to any is a bit of a cheat, but it allows us to check - // each option individually without having to do a bunch of type guards. - const opts = options as any; - if (opts.format !== undefined) validateString(opts.format, "options.format"); - if (opts.type !== undefined) validateString(opts.type, "options.type"); - if (this.type === "private") { - if (opts.cipher !== undefined) { - validateString(opts.cipher, "options.cipher"); - if (typeof opts.passphrase === "string") { - opts.passphrase = Buffer.from(opts.passphrase, opts.encoding); - } - if (!isUint8Array(opts.passphrase)) { - throw new ERR_INVALID_ARG_TYPE( - "options.passphrase", - ["string", "Uint8Array"], - opts.passphrase - ); - } - } + } + + export(options: ExportOptions = {}) : KeyExportResult { + validateObject(options, 'options', {}); + + // Yes, converting to any is a bit of a cheat, but it allows us to check + // each option individually without having to do a bunch of type guards. + const opts = options as any; + if (opts.format !== undefined) validateString(opts.format, 'options.format'); + if (opts.type !== undefined) validateString(opts.type, 'options.type'); + if (this.type === 'private') { + if (opts.cipher !== undefined) { + validateString(opts.cipher, 'options.cipher'); + if (typeof opts.passphrase === 'string') { + opts.passphrase = Buffer.from(opts.passphrase, opts.encoding); } - - const ret = cryptoImpl.exportKey(this[kHandle], options as InnerExportOptions); - if (typeof ret === "string") return ret; - if (isUint8Array(ret)) { - return Buffer.from( - (ret as Uint8Array).buffer, - ret.byteOffset, - ret.byteLength - ) as KeyExportResult; - } else if (isArrayBuffer(ret)) { - return Buffer.from(ret as ArrayBuffer, 0, (ret as ArrayBuffer).byteLength); + if (!isUint8Array(opts.passphrase)) { + throw new ERR_INVALID_ARG_TYPE('options.passphrase', [ + 'string', 'Uint8Array' + ], opts.passphrase); } - return ret; + } } - equals(otherKeyObject: KeyObject): boolean { - if (this === otherKeyObject || this[kHandle] === otherKeyObject[kHandle]) return true; - if (this.type !== otherKeyObject.type) return false; - if (!(otherKeyObject[kHandle] instanceof CryptoKey)) { - throw new ERR_INVALID_ARG_TYPE("otherKeyObject", "KeyObject", otherKeyObject); - } - return cryptoImpl.equals(this[kHandle], otherKeyObject[kHandle]); + const ret = cryptoImpl.exportKey(this[kHandle], options as InnerExportOptions); + if (typeof ret === 'string') return ret; + if (isUint8Array(ret)) { + return Buffer.from((ret as Uint8Array).buffer, ret.byteOffset, ret.byteLength) as KeyExportResult; + } else if (isArrayBuffer(ret)) { + return Buffer.from(ret as ArrayBuffer, 0, (ret as ArrayBuffer).byteLength); } + return ret; + } + + equals(otherKeyObject: KeyObject) : boolean { + if (this === otherKeyObject || + this[kHandle] === otherKeyObject[kHandle]) return true; + if (this.type !== otherKeyObject.type) return false; + if (!(otherKeyObject[kHandle] instanceof CryptoKey)) { + throw new ERR_INVALID_ARG_TYPE('otherKeyObject', 'KeyObject', otherKeyObject); + } + return cryptoImpl.equals(this[kHandle], otherKeyObject[kHandle]); + } - abstract get type(): KeyObjectType; + abstract get type() : KeyObjectType; } abstract class AsymmetricKeyObject extends KeyObject { - get asymmetricKeyDetails(): AsymmetricKeyDetails { - let detail = cryptoImpl.getAsymmetricKeyDetail(this[kHandle]); - if (isArrayBuffer(detail.publicExponent)) { - detail.publicExponent = arrayBufferToUnsignedBigInt(detail.publicExponent as any); - } - return detail; + get asymmetricKeyDetails() : AsymmetricKeyDetails { + let detail = cryptoImpl.getAsymmetricKeyDetail(this[kHandle]); + if (isArrayBuffer(detail.publicExponent)) { + detail.publicExponent = arrayBufferToUnsignedBigInt(detail.publicExponent as any); } + return detail; + } - get asymmetricKeyType(): AsymmetricKeyType { - return cryptoImpl.getAsymmetricKeyType(this[kHandle]); - } + get asymmetricKeyType() : AsymmetricKeyType { + return cryptoImpl.getAsymmetricKeyType(this[kHandle]); + } } export class PublicKeyObject extends AsymmetricKeyObject { - override export(options?: PublicKeyExportOptions): KeyExportResult { - return super.export(options); - } + override export(options?: PublicKeyExportOptions) : KeyExportResult { + return super.export(options); + } - get type(): KeyObjectType { - return "public"; - } + get type() : KeyObjectType { return 'public'; } } export class PrivateKeyObject extends AsymmetricKeyObject { - override export(options?: PrivateKeyExportOptions): KeyExportResult { - return super.export(options); - } + override export(options?: PrivateKeyExportOptions) : KeyExportResult { + return super.export(options); + } - get type(): KeyObjectType { - return "private"; - } + get type() : KeyObjectType { return 'private'; } } export class SecretKeyObject extends KeyObject { - get symmetricKeySize(): number { - return (this[kHandle].algorithm as any).length | 0; - } + get symmetricKeySize() : number { + return (this[kHandle].algorithm as any).length | 0 + } - override export(options?: SecretKeyExportOptions): KeyExportResult { - return super.export(options); - } + override export(options?: SecretKeyExportOptions) : KeyExportResult { + return super.export(options); + } - get type(): KeyObjectType { - return "secret"; - } + get type() : KeyObjectType { return 'secret'; } } type ValidateKeyDataOptions = { - allowObject?: boolean; + allowObject?: boolean; }; -function validateKeyData( - key: unknown, - name: string, - options: ValidateKeyDataOptions = { - allowObject: false, - } -) { - if ( - key == null || - (typeof key !== "string" && - options.allowObject && - typeof key !== "object" && - !isArrayBufferView(key) && - !isAnyArrayBuffer(key)) - ) { - const expected = ["string", "ArrayBuffer", "TypedArray", "DataView"]; - if (options.allowObject) expected.push("object"); - throw new ERR_INVALID_ARG_TYPE(name, expected, key); - } +function validateKeyData(key: unknown, name: string, options : ValidateKeyDataOptions = { + allowObject: false, +}) { + if (key == null || + (typeof key !== 'string' && + (options.allowObject && typeof key !== 'object') && + !isArrayBufferView(key) && + !isAnyArrayBuffer(key))) { + const expected = [ + 'string', + 'ArrayBuffer', + 'TypedArray', + 'DataView' + ]; + if (options.allowObject) expected.push('object'); + throw new ERR_INVALID_ARG_TYPE(name, expected, key); + } } -export function createSecretKey(key: string, encoding?: string): SecretKeyObject; -export function createSecretKey(key: ArrayBuffer | ArrayBufferView): SecretKeyObject; -export function createSecretKey(key: KeyData, encoding?: string): SecretKeyObject { - validateKeyData(key, "key"); - if (typeof key === "string") key = Buffer.from(key as string, encoding); - return KeyObject.from(cryptoImpl.createSecretKey(key)) as SecretKeyObject; +export function createSecretKey(key: string, encoding?: string) : SecretKeyObject; +export function createSecretKey(key: ArrayBuffer | ArrayBufferView) : SecretKeyObject; +export function createSecretKey(key: KeyData, encoding?: string) : SecretKeyObject { + validateKeyData(key, 'key'); + if (typeof key === 'string') key = Buffer.from(key as string, encoding); + return KeyObject.from(cryptoImpl.createSecretKey(key)) as SecretKeyObject; } // TODO(soon): Fully implement createPrivateKey/createPublicKey. These are the @@ -309,41 +294,40 @@ export function createSecretKey(key: KeyData, encoding?: string): SecretKeyObjec // return inner; // } -export function createPrivateKey(key: string): PrivateKeyObject; -export function createPrivateKey(key: ArrayBuffer | ArrayBufferView): PrivateKeyObject; -export function createPrivateKey(key: CreateAsymmetricKeyOptions): PrivateKeyObject; -export function createPrivateKey(_key: CreateAsymmetricKeyOptions | KeyData): PrivateKeyObject { - // The options here are fairly complex. The key data can be a string, - // ArrayBuffer, or ArrayBufferView. The first argument can be one of - // these or an object with a key property that is one of these. If the - // key data is a string, then it will be decoded using an encoding - // (defaults to UTF8). - throw new ERR_METHOD_NOT_IMPLEMENTED("crypto.createPrivateKey"); - // return KeyObject.from(cryptoImpl.createPrivateKey( - // validateAsymmetricKeyOptions(key, kPrivateKey))) as PrivateKeyObject; +export function createPrivateKey(key: string) : PrivateKeyObject; +export function createPrivateKey(key: ArrayBuffer | ArrayBufferView) : PrivateKeyObject; +export function createPrivateKey(key: CreateAsymmetricKeyOptions) : PrivateKeyObject; +export function createPrivateKey(_key: CreateAsymmetricKeyOptions | KeyData) : PrivateKeyObject { + // The options here are fairly complex. The key data can be a string, + // ArrayBuffer, or ArrayBufferView. The first argument can be one of + // these or an object with a key property that is one of these. If the + // key data is a string, then it will be decoded using an encoding + // (defaults to UTF8). + throw new ERR_METHOD_NOT_IMPLEMENTED('crypto.createPrivateKey'); + // return KeyObject.from(cryptoImpl.createPrivateKey( + // validateAsymmetricKeyOptions(key, kPrivateKey))) as PrivateKeyObject; } -export function createPublicKey(key: string): PublicKeyObject; -export function createPublicKey(key: ArrayBuffer): PublicKeyObject; -export function createPublicKey(key: ArrayBufferView): PublicKeyObject; - -export function createPublicKey(key: KeyObject): PublicKeyObject; -export function createPublicKey(key: CryptoKey): PublicKeyObject; -export function createPublicKey(key: CreateAsymmetricKeyOptions): PublicKeyObject; -export function createPublicKey( - _key: CreateAsymmetricKeyOptions | KeyData | CryptoKey | KeyObject -): PublicKeyObject { - // The options here are a bit complicated. The key material itself can - // either be a string, ArrayBuffer, or ArrayBufferView. It is also - // possible to pass a private key in the form of either a CryptoKey - // or KeyObject. The first argument can be one of these, or an object - // whose key value is one of these. If the key data is a string, then - // it will be decoded using an encoding (defaults to UTF8). If a - // CryptoKey or KeyObject is passed, it will be used to derived the - // public key. - throw new ERR_METHOD_NOT_IMPLEMENTED("crypto.createPublicKey"); - // return KeyObject.from(cryptoImpl.createPublicKey( - // validateAsymmetricKeyOptions(key, kPublicKey))) as PublicKeyObject; +export function createPublicKey(key: string) : PublicKeyObject; +export function createPublicKey(key: ArrayBuffer) : PublicKeyObject; +export function createPublicKey(key: ArrayBufferView) : PublicKeyObject; + +export function createPublicKey(key: KeyObject) : PublicKeyObject; +export function createPublicKey(key: CryptoKey) : PublicKeyObject; +export function createPublicKey(key: CreateAsymmetricKeyOptions) : PublicKeyObject; +export function createPublicKey(_key: CreateAsymmetricKeyOptions | KeyData | CryptoKey | KeyObject) + : PublicKeyObject { + // The options here are a bit complicated. The key material itself can + // either be a string, ArrayBuffer, or ArrayBufferView. It is also + // possible to pass a private key in the form of either a CryptoKey + // or KeyObject. The first argument can be one of these, or an object + // whose key value is one of these. If the key data is a string, then + // it will be decoded using an encoding (defaults to UTF8). If a + // CryptoKey or KeyObject is passed, it will be used to derived the + // public key. + throw new ERR_METHOD_NOT_IMPLEMENTED('crypto.createPublicKey'); + // return KeyObject.from(cryptoImpl.createPublicKey( + // validateAsymmetricKeyOptions(key, kPublicKey))) as PublicKeyObject; } // ====================================================================================== @@ -351,56 +335,50 @@ export function createPublicKey( export type PublicKeyResult = KeyExportResult | PublicKeyObject; export type PrivateKeyResult = KeyExportResult | PrivateKeyObject; export type GenerateKeyCallback = (err?: any, key?: KeyObject) => void; -export type GenerateKeyPairCallback = ( - err?: any, - publicKey?: PublicKeyResult, - privateKey?: PrivateKeyResult -) => void; +export type GenerateKeyPairCallback = + (err?: any, publicKey?: PublicKeyResult, privateKey?: PrivateKeyResult) => void; export interface KeyObjectPair { - publicKey: PublicKeyResult; - privateKey: PrivateKeyResult; + publicKey: PublicKeyResult; + privateKey: PrivateKeyResult; } -export function generateKey( - _type: SecretKeyType, - _options: GenerateKeyOptions, - callback: GenerateKeyCallback -) { - // We intentionally have not implemented key generation up to this point. - // The reason is that generation of cryptographically safe keys is a CPU - // intensive operation that can often exceed limits on the amount of CPU - // time a worker is allowed. - callback(new ERR_METHOD_NOT_IMPLEMENTED("crypto.generateKeySync")); +export function generateKey(_type: SecretKeyType, + _options: GenerateKeyOptions, + callback: GenerateKeyCallback) { +// We intentionally have not implemented key generation up to this point. +// The reason is that generation of cryptographically safe keys is a CPU +// intensive operation that can often exceed limits on the amount of CPU +// time a worker is allowed. +callback(new ERR_METHOD_NOT_IMPLEMENTED('crypto.generateKeySync')); } -export function generateKeySync(_type: SecretKeyType, _options: GenerateKeyOptions) { - // We intentionally have not implemented key generation up to this point. - // The reason is that generation of cryptographically safe keys is a CPU - // intensive operation that can often exceed limits on the amount of CPU - // time a worker is allowed. - throw new ERR_METHOD_NOT_IMPLEMENTED("crypto.generateKeySync"); +export function generateKeySync(_type: SecretKeyType, + _options: GenerateKeyOptions) { +// We intentionally have not implemented key generation up to this point. +// The reason is that generation of cryptographically safe keys is a CPU +// intensive operation that can often exceed limits on the amount of CPU +// time a worker is allowed. +throw new ERR_METHOD_NOT_IMPLEMENTED('crypto.generateKeySync'); } export function generateKeyPair( - _type: AsymmetricKeyType, + _type : AsymmetricKeyType, _options: GenerateKeyPairOptions, - callback: GenerateKeyPairCallback -) { - // We intentionally have not implemented key generation up to this point. - // The reason is that generation of cryptographically safe keys is a CPU - // intensive operation that can often exceed limits on the amount of CPU - // time a worker is allowed. - callback(new ERR_METHOD_NOT_IMPLEMENTED("crypto.generateKeyPair")); + callback: GenerateKeyPairCallback) { + // We intentionally have not implemented key generation up to this point. + // The reason is that generation of cryptographically safe keys is a CPU + // intensive operation that can often exceed limits on the amount of CPU + // time a worker is allowed. + callback(new ERR_METHOD_NOT_IMPLEMENTED('crypto.generateKeyPair')); } export function generateKeyPairSync( - _type: AsymmetricKeyType, - _options: GenerateKeyPairOptions -): KeyObjectPair { - // We intentionally have not implemented key generation up to this point. - // The reason is that generation of cryptographically safe keys is a CPU - // intensive operation that can often exceed limits on the amount of CPU - // time a worker is allowed. - throw new ERR_METHOD_NOT_IMPLEMENTED("crypto.generateKeyPairSync"); + _type : AsymmetricKeyType, + _options: GenerateKeyPairOptions) : KeyObjectPair { + // We intentionally have not implemented key generation up to this point. + // The reason is that generation of cryptographically safe keys is a CPU + // intensive operation that can often exceed limits on the amount of CPU + // time a worker is allowed. + throw new ERR_METHOD_NOT_IMPLEMENTED('crypto.generateKeyPairSync'); } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_pbkdf2.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_pbkdf2.ts index 3d575b53a..40772a90c 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_pbkdf2.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_pbkdf2.ts @@ -1,85 +1,64 @@ /* eslint-disable */ -"use strict"; +'use strict'; -import * as cryptoImpl from "./crypto"; +import * as cryptoImpl from './crypto'; type ArrayLike = cryptoImpl.ArrayLike; -export { ArrayLike }; +export {ArrayLike}; -import { Buffer } from "./internal_buffer"; +import { + Buffer, +} from './internal_buffer'; -import { validateInt32, validateFunction, validateString } from "./validators"; +import { + validateInt32, + validateFunction, + validateString, +} from './validators'; -import { getArrayBufferOrView } from "./crypto_util"; +import { + getArrayBufferOrView, +} from './crypto_util'; -export function pbkdf2Sync( - password: ArrayLike, - salt: ArrayLike, - iterations: number, - keylen: number, - digest: string -): Buffer { - ({ password, salt, iterations, keylen, digest } = check( - password, - salt, - iterations, - keylen, - digest - )); +export function pbkdf2Sync(password: ArrayLike, salt: ArrayLike, iterations: number, + keylen: number, digest: string): Buffer { + ({ password, salt, iterations, keylen, digest } = + check(password, salt, iterations, keylen, digest)); - const result = cryptoImpl.getPbkdf(password, salt, iterations, keylen, digest); - return Buffer.from(result); + const result = cryptoImpl.getPbkdf(password, salt, iterations, keylen, digest); + return Buffer.from(result); } -export type Pbkdf2Callback = (err?: Error | null, result?: Buffer) => void; -export function pbkdf2( - password: ArrayLike, - salt: ArrayLike, - iterations: number, - keylen: number, - digest: string, - callback: Pbkdf2Callback -): void { - if (typeof digest === "function") { - // Appease node test cases - validateString(undefined, "digest"); - } - validateFunction(callback, "callback"); - ({ password, salt, iterations, keylen, digest } = check( - password, - salt, - iterations, - keylen, - digest - )); +export type Pbkdf2Callback = (err?: Error|null, result?: Buffer) => void; +export function pbkdf2(password: ArrayLike, salt: ArrayLike, iterations: number, keylen: number, + digest: string, callback: Pbkdf2Callback): void { + if (typeof digest === 'function') { + // Appease node test cases + validateString(undefined, 'digest'); + } + validateFunction(callback, 'callback'); + ({ password, salt, iterations, keylen, digest } = + check(password, salt, iterations, keylen, digest)); - new Promise((res, rej) => { - try { - res(cryptoImpl.getPbkdf(password, salt, iterations, keylen, digest)); - } catch (err) { - rej(err); - } - }).then( - (val) => callback(null, Buffer.from(val)), - (err) => callback(err) - ); + new Promise((res, rej) => { + try { + res(cryptoImpl.getPbkdf(password, salt, iterations, keylen, digest)); + } catch(err) { + rej(err); + } + }).then((val) => callback(null, Buffer.from(val)), (err) => callback(err)); } -function check( - password: ArrayLike | ArrayBufferView, - salt: ArrayLike | ArrayBufferView, - iterations: number, - keylen: number, - digest: string -): any { - validateString(digest, "digest"); +function check(password: ArrayLike|ArrayBufferView, salt: ArrayLike|ArrayBufferView, iterations: number, keylen: number, + digest: string): any { + validateString(digest, 'digest'); - password = getArrayBufferOrView(password, "password"); - salt = getArrayBufferOrView(salt, "salt"); - // OpenSSL uses a signed int to represent these values, so we are restricted - // to the 31-bit range here (which is plenty). - validateInt32(iterations, "iterations", 1); - validateInt32(keylen, "keylen", 0); + password = getArrayBufferOrView(password, 'password'); + salt = getArrayBufferOrView(salt, 'salt'); + // OpenSSL uses a signed int to represent these values, so we are restricted + // to the 31-bit range here (which is plenty). + validateInt32(iterations, 'iterations', 1); + validateInt32(keylen, 'keylen', 0); - return { password, salt, iterations, keylen, digest }; + return { password, salt, iterations, keylen, digest }; } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_random.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_random.ts index ac49474c8..64c0a58a1 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_random.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_random.ts @@ -1,126 +1,127 @@ /* eslint-disable */ -import * as cryptoImpl from "./crypto"; +import * as cryptoImpl from './crypto'; import { - validateObject, - validateBoolean, - validateFunction, - validateInt32, - validateInteger, -} from "./validators"; + validateObject, + validateBoolean, + validateFunction, + validateInt32, + validateInteger, +} from './validators'; -import { isAnyArrayBuffer, isArrayBufferView } from "./internal_types"; +import { + isAnyArrayBuffer, + isArrayBufferView +} from './internal_types'; -import { ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } from "./internal_errors"; +import { + ERR_INVALID_ARG_TYPE, + ERR_OUT_OF_RANGE, +} from './internal_errors'; -import { Buffer, kMaxLength } from "./internal_buffer"; +import { + Buffer, + kMaxLength +} from './internal_buffer'; -import { arrayBufferToUnsignedBigInt } from "./crypto_util"; +import { + arrayBufferToUnsignedBigInt, +} from './crypto_util'; -export type RandomBytesCallback = (err: any | null, buffer: Uint8Array) => void; +export type RandomBytesCallback = (err: any|null, buffer: Uint8Array) => void; export function randomBytes(size: number, callback: RandomBytesCallback): void; export function randomBytes(size: number): Uint8Array; -export function randomBytes(size: number, callback?: RandomBytesCallback): Uint8Array | void { - validateInteger(size, "size", 0, kMaxLength); - const buf = Buffer.alloc(size); - if (callback !== undefined) { - randomFill(buf, callback as RandomFillCallback); - } else { - randomFillSync(buf); - return buf; - } +export function randomBytes(size: number, callback?: RandomBytesCallback) : Uint8Array|void{ + validateInteger(size, 'size', 0, kMaxLength); + const buf = Buffer.alloc(size); + if (callback !== undefined) { + randomFill(buf, callback as RandomFillCallback); + } else { + randomFillSync(buf); + return buf; + } } export function randomFillSync( - buffer: ArrayBufferView | ArrayBuffer, + buffer: ArrayBufferView|ArrayBuffer, offset?: number, - size?: number -) { - if (!isAnyArrayBuffer(buffer) && !isArrayBufferView(buffer)) { - throw new ERR_INVALID_ARG_TYPE( - "buffer", - ["TypedArray", "DataView", "ArrayBuffer", "SharedArrayBuffer"], - buffer - ); - } - const maxLength = (buffer as Uint8Array).length; - if (offset !== undefined) { - validateInteger(offset!, "offset", 0, kMaxLength); - } else offset = 0; - if (size !== undefined) { - validateInteger(size!, "size", 0, maxLength - offset); - } else size = maxLength; - if (isAnyArrayBuffer(buffer)) { - buffer = Buffer.from(buffer as ArrayBuffer); - } - buffer = (buffer as Buffer).subarray(offset, offset + size); - return crypto.getRandomValues(buffer as ArrayBufferView); + size?: number) { + if (!isAnyArrayBuffer(buffer) && !isArrayBufferView(buffer)) { + throw new ERR_INVALID_ARG_TYPE('buffer', [ + 'TypedArray', + 'DataView', + 'ArrayBuffer', + 'SharedArrayBuffer' + ],buffer); + } + const maxLength = (buffer as Uint8Array).length; + if (offset !== undefined) { + validateInteger(offset!, 'offset', 0, kMaxLength); + } else offset = 0; + if (size !== undefined) { + validateInteger(size!, 'size', 0, maxLength - offset); + } else size = maxLength; + if (isAnyArrayBuffer(buffer)) { + buffer = Buffer.from(buffer as ArrayBuffer); + } + buffer = (buffer as Buffer).subarray(offset, offset + size); + return crypto.getRandomValues(buffer as ArrayBufferView); } -export type RandomFillCallback = (err: any | null, buf?: ArrayBufferView | ArrayBuffer) => void; -export function randomFill( - buffer: ArrayBufferView | ArrayBuffer, - callback?: RandomFillCallback -): void; -export function randomFill( - buffer: ArrayBufferView | ArrayBuffer, - offset: number, - callback?: RandomFillCallback -): void; -export function randomFill( - buffer: ArrayBufferView | ArrayBuffer, - offset: number, - size: number, - callback?: RandomFillCallback -): void; -export function randomFill( - buffer: ArrayBufferView | ArrayBuffer, - offsetOrCallback?: number | RandomFillCallback, - sizeOrCallback?: number | RandomFillCallback, - callback?: RandomFillCallback -) { - if (!isAnyArrayBuffer(buffer) && !isArrayBufferView(buffer)) { - throw new ERR_INVALID_ARG_TYPE( - "buffer", - ["TypedArray", "DataView", "ArrayBuffer", "SharedArrayBuffer"], - buffer - ); - } - - let offset = 0; - let size = 0; - const maxLength = (buffer as Uint8Array).length; - if (typeof callback === "function") { - validateInteger(offsetOrCallback, "offset", 0, maxLength); - offset = offsetOrCallback as number; - - validateInteger(sizeOrCallback, "size", 0, maxLength - offset); - size = sizeOrCallback as number; - } else if (typeof sizeOrCallback === "function") { - validateInteger(offsetOrCallback, "offset", 0, maxLength); - offset = offsetOrCallback as number; - size = maxLength - offset; - callback = sizeOrCallback as RandomFillCallback; - } else if (typeof offsetOrCallback === "function") { - offset = 0; - size = maxLength; - callback = offsetOrCallback as RandomFillCallback; - } - validateFunction(callback, "callback"); - - // We're currently not actually implementing the fill itself asynchronously, - // so we defer to randomFillSync here, but we invoke the callback asynchronously. - new Promise((res) => { - randomFillSync(buffer, offset, size); - res(); - }).then( - () => callback!(null, buffer), - (err: any) => callback!(err) - ); +export type RandomFillCallback = (err: any|null, buf?: ArrayBufferView|ArrayBuffer) => void; +export function randomFill(buffer: ArrayBufferView|ArrayBuffer, + callback?: RandomFillCallback) : void; +export function randomFill(buffer: ArrayBufferView|ArrayBuffer, + offset: number, + callback?: RandomFillCallback) : void; + export function randomFill(buffer: ArrayBufferView|ArrayBuffer, + offset: number, + size: number, + callback?: RandomFillCallback) : void; +export function randomFill(buffer: ArrayBufferView|ArrayBuffer, + offsetOrCallback?: number|RandomFillCallback, + sizeOrCallback?: number|RandomFillCallback, + callback?: RandomFillCallback) { + if (!isAnyArrayBuffer(buffer) && !isArrayBufferView(buffer)) { + throw new ERR_INVALID_ARG_TYPE('buffer', [ + 'TypedArray', + 'DataView', + 'ArrayBuffer', + 'SharedArrayBuffer' + ],buffer); + } + + let offset = 0; + let size = 0; + const maxLength = (buffer as Uint8Array).length; + if (typeof callback === 'function') { + validateInteger(offsetOrCallback, 'offset', 0, maxLength); + offset = offsetOrCallback as number; + + validateInteger(sizeOrCallback, 'size', 0, maxLength - offset); + size = sizeOrCallback as number; + } else if (typeof sizeOrCallback === 'function') { + validateInteger(offsetOrCallback, 'offset', 0, maxLength); + offset = offsetOrCallback as number; + size = maxLength - offset; + callback = sizeOrCallback as RandomFillCallback; + } else if (typeof offsetOrCallback === 'function') { + offset = 0; + size = maxLength; + callback = offsetOrCallback as RandomFillCallback; + } + validateFunction(callback, 'callback'); + + // We're currently not actually implementing the fill itself asynchronously, + // so we defer to randomFillSync here, but we invoke the callback asynchronously. + new Promise((res) => { + randomFillSync(buffer, offset, size); + res(); + }).then(() => callback!(null, buffer), (err: any) => callback!(err)); } -const RAND_MAX = 0xffff_ffff_ffff; +const RAND_MAX = 0xFFFF_FFFF_FFFF; // Cache random data to use in randomInt. The cache size must be evenly // divisible by 6 because each attempt to obtain a random int uses 6 bytes. const randomCache = Buffer.alloc(6 * 1024); @@ -128,266 +129,282 @@ let randomCacheOffset = 0; let initialized = false; function getRandomInt(min: number, max: number) { - if (!initialized) { - randomFillSync(randomCache); - initialized = true; - } - // First we generate a random int between [0..range) - const range = max - min; - - if (!(range <= RAND_MAX)) { - throw new ERR_OUT_OF_RANGE(`max${max ? "" : " - min"}`, `<= ${RAND_MAX}`, range); + if (!initialized) { + randomFillSync(randomCache); + initialized = true; + } + // First we generate a random int between [0..range) + const range = max - min; + + if (!(range <= RAND_MAX)) { + throw new ERR_OUT_OF_RANGE(`max${max ? '' : ' - min'}`, `<= ${RAND_MAX}`, range); + } + + // For (x % range) to produce an unbiased value greater than or equal to 0 and + // less than range, x must be drawn randomly from the set of integers greater + // than or equal to 0 and less than randLimit. + const randLimit = RAND_MAX - (RAND_MAX % range); + + // If we don't have a callback, or if there is still data in the cache, we can + // do this synchronously, which is super fast. + while (randomCacheOffset <= randomCache.length) { + if (randomCacheOffset === randomCache.length) { + // This might block the thread for a bit, but we are in sync mode. + randomFillSync(randomCache); + randomCacheOffset = 0; } - // For (x % range) to produce an unbiased value greater than or equal to 0 and - // less than range, x must be drawn randomly from the set of integers greater - // than or equal to 0 and less than randLimit. - const randLimit = RAND_MAX - (RAND_MAX % range); - - // If we don't have a callback, or if there is still data in the cache, we can - // do this synchronously, which is super fast. - while (randomCacheOffset <= randomCache.length) { - if (randomCacheOffset === randomCache.length) { - // This might block the thread for a bit, but we are in sync mode. - randomFillSync(randomCache); - randomCacheOffset = 0; - } - - const x = randomCache.readUIntBE(randomCacheOffset, 6); - randomCacheOffset += 6; - if (x < randLimit) { - const n = (x % range) + min; - return n; - } + const x = randomCache.readUIntBE(randomCacheOffset, 6); + randomCacheOffset += 6; + if (x < randLimit) { + const n = (x % range) + min; + return n; } - return 0; // Should be unreachable. + } + return 0; // Should be unreachable. } -export type RandomIntCallback = (err: any | null, n?: number) => void; -export function randomInt(max: number): number; -export function randomInt(min: number, max: number): number; -export function randomInt(max: number, callback: RandomIntCallback): void; -export function randomInt(min: number, max: number, callback: RandomIntCallback): void; -export function randomInt( - minOrMax: number, - maxOrCallback?: number | RandomIntCallback, - callback?: RandomIntCallback -) { - let min = 0; - let max = 0; - if (typeof callback === "function") { - validateInteger(minOrMax, "min"); - validateInteger(maxOrCallback, "max"); - min = minOrMax as number; - max = maxOrCallback as number; - } else if (typeof maxOrCallback === "function") { - min = 0; - validateInteger(minOrMax, "max"); - max = minOrMax as number; - callback = maxOrCallback as RandomIntCallback; - } else if (arguments.length === 2) { - validateInteger(minOrMax, "min"); - validateInteger(maxOrCallback, "max"); - min = minOrMax as number; - max = maxOrCallback as number; - } else { - min = 0; - validateInteger(minOrMax, "max"); - max = minOrMax; - } - - if (min > max) { - throw new ERR_OUT_OF_RANGE("min", "min <= max", min); - } - - if (callback !== undefined) { - new Promise((res) => { - res(getRandomInt(min, max)); - }).then( - (n: number) => callback!(null, n), - (err: any) => callback!(err) - ); - return; - } else { - return getRandomInt(min, max); - } +export type RandomIntCallback = (err: any|null, n?: number) => void; +export function randomInt(max: number) : number; +export function randomInt(min: number, max: number) : number; +export function randomInt(max: number, callback: RandomIntCallback) : void; +export function randomInt(min: number, max: number, callback: RandomIntCallback) : void; +export function randomInt(minOrMax: number, + maxOrCallback?: number|RandomIntCallback, + callback?: RandomIntCallback) { + let min = 0; + let max = 0; + if (typeof callback === 'function') { + validateInteger(minOrMax, 'min'); + validateInteger(maxOrCallback, 'max'); + min = minOrMax as number; + max = maxOrCallback as number; + } else if (typeof maxOrCallback === 'function') { + min = 0; + validateInteger(minOrMax, 'max'); + max = minOrMax as number; + callback = maxOrCallback as RandomIntCallback; + } else if (arguments.length === 2) { + validateInteger(minOrMax, 'min'); + validateInteger(maxOrCallback, 'max'); + min = minOrMax as number; + max = maxOrCallback as number; + } else { + min = 0; + validateInteger(minOrMax, 'max'); + max = minOrMax; + } + + if (min > max) { + throw new ERR_OUT_OF_RANGE('min', 'min <= max', min); + } + + if (callback !== undefined) { + new Promise((res) => { + res(getRandomInt(min, max)); + }).then((n: number) => callback!(null, n), (err: any) => callback!(err)); + return; + } else { + return getRandomInt(min, max); + } } export function randomUUID(options?: any) { - // While we do not actually use the entropy cache, we go ahead and validate - // the input parameters as Node.js does. - if (options !== undefined) { - validateObject(options, "options", options); - if (options.disableEntropyCache !== undefined) { - validateBoolean(options.disableEntropyCache, "options.disableEntropyCache"); - } + // While we do not actually use the entropy cache, we go ahead and validate + // the input parameters as Node.js does. + if (options !== undefined) { + validateObject(options, 'options', options); + if (options.disableEntropyCache !== undefined) { + validateBoolean(options.disableEntropyCache, 'options.disableEntropyCache'); } - return crypto.randomUUID(); + } + return crypto.randomUUID(); } export type PrimeNum = ArrayBuffer | ArrayBufferView | Buffer | bigint; export interface GeneratePrimeOptions { - add?: PrimeNum; - rem?: PrimeNum; - safe?: boolean; - bigint?: boolean; + add?: PrimeNum; + rem?: PrimeNum; + safe?: boolean; + bigint?: boolean; } export interface CheckPrimeOptions { - checks?: number; + checks?: number; } -export type GeneratePrimeCallback = (err?: any, prime?: bigint | ArrayBuffer) => void; +export type GeneratePrimeCallback = (err?: any, prime?: bigint|ArrayBuffer) => void; export type CheckPrimeCallback = (err?: any, prime?: boolean) => void; -function processGeneratePrimeOptions(options: GeneratePrimeOptions): { - add: ArrayBufferView; - rem: ArrayBufferView; - safe: boolean; - bigint: boolean; -} { - validateObject(options, "options", {}); - const { safe = false, bigint = false } = options; - let { add, rem } = options; - validateBoolean(safe, "options.safe"); - validateBoolean(bigint, "options.bigint"); - - if (add !== undefined) { - if (typeof add === "bigint") { - add = unsignedBigIntToBuffer(add, "options.add"); - } else if (!isAnyArrayBuffer(add) && !isArrayBufferView(add)) { - throw new ERR_INVALID_ARG_TYPE( - "options.add", - ["ArrayBuffer", "TypedArray", "Buffer", "DataView", "bigint"], - add - ); - } +function processGeneratePrimeOptions(options: GeneratePrimeOptions) : { + add: ArrayBufferView, + rem: ArrayBufferView, + safe: boolean, + bigint: boolean } { + validateObject(options, 'options', {}); + const { + safe = false, + bigint = false, + } = options; + let { + add, + rem, + } = options; + validateBoolean(safe, 'options.safe'); + validateBoolean(bigint, 'options.bigint'); + + if (add !== undefined) { + if (typeof add === 'bigint') { + add = unsignedBigIntToBuffer(add, 'options.add'); + } else if (!isAnyArrayBuffer(add) && !isArrayBufferView(add)) { + throw new ERR_INVALID_ARG_TYPE( + 'options.add', + [ + 'ArrayBuffer', + 'TypedArray', + 'Buffer', + 'DataView', + 'bigint', + ], + add); } - - if (rem !== undefined) { - if (typeof rem === "bigint") { - rem = unsignedBigIntToBuffer(rem, "options.rem"); - } else if (!isAnyArrayBuffer(rem) && !isArrayBufferView(rem)) { - throw new ERR_INVALID_ARG_TYPE( - "options.rem", - ["ArrayBuffer", "TypedArray", "Buffer", "DataView", "bigint"], - rem - ); - } + } + + if (rem !== undefined) { + if (typeof rem === 'bigint') { + rem = unsignedBigIntToBuffer(rem, 'options.rem'); + } else if (!isAnyArrayBuffer(rem) && !isArrayBufferView(rem)) { + throw new ERR_INVALID_ARG_TYPE( + 'options.rem', + [ + 'ArrayBuffer', + 'TypedArray', + 'Buffer', + 'DataView', + 'bigint', + ], + rem); } - - return { - safe, - bigint, - add: add as ArrayBufferView, - rem: rem as ArrayBufferView, - }; + } + + return { + safe, + bigint, + add: add as ArrayBufferView, + rem: rem as ArrayBufferView, + } } export function generatePrimeSync(size: number, options: GeneratePrimeOptions = {}) { - validateInt32(size, "size", 1); - const { safe, bigint, add, rem } = processGeneratePrimeOptions(options); - - let primeBuf = cryptoImpl.randomPrime(size, safe, add, rem); - return bigint ? arrayBufferToUnsignedBigInt(primeBuf) : primeBuf; + validateInt32(size, 'size', 1); + const { + safe, + bigint, + add, + rem, + } = processGeneratePrimeOptions(options); + + let primeBuf = cryptoImpl.randomPrime(size, safe, add, rem); + return bigint ? arrayBufferToUnsignedBigInt(primeBuf) : primeBuf; } -export function generatePrime( - size: number, - options: GeneratePrimeOptions, - callback: GeneratePrimeCallback -): void; -export function generatePrime(size: number, callback: GeneratePrimeCallback): void; -export function generatePrime( - size: number, - options: GeneratePrimeOptions | GeneratePrimeCallback, - callback?: GeneratePrimeCallback -): void { - validateInt32(size, "size", 1); - if (typeof options === "function") { - callback = options; - options = {}; +export function generatePrime(size: number, + options: GeneratePrimeOptions, + callback: GeneratePrimeCallback) : void; +export function generatePrime(size: number, callback: GeneratePrimeCallback) : void; +export function generatePrime(size: number, + options: GeneratePrimeOptions|GeneratePrimeCallback, + callback?: GeneratePrimeCallback) : void { + validateInt32(size, 'size', 1); + if (typeof options === 'function') { + callback = options; + options = {}; + } + validateFunction(callback, 'callback'); + + const { + safe, + bigint, + add, + rem + } = processGeneratePrimeOptions(options as GeneratePrimeOptions); + + new Promise((res, rej) => { + try { + const primeBuf = cryptoImpl.randomPrime(size, safe, add, rem); + res(bigint ? arrayBufferToUnsignedBigInt(primeBuf) : primeBuf); + } catch(err) { + rej(err); } - validateFunction(callback, "callback"); - - const { safe, bigint, add, rem } = processGeneratePrimeOptions(options as GeneratePrimeOptions); - - new Promise((res, rej) => { - try { - const primeBuf = cryptoImpl.randomPrime(size, safe, add, rem); - res(bigint ? arrayBufferToUnsignedBigInt(primeBuf) : primeBuf); - } catch (err) { - rej(err); - } - }).then( - (val) => callback!(null, val), - (err) => callback!(err) - ); + }).then((val) => callback!(null, val), (err) => callback!(err)); } function unsignedBigIntToBuffer(bigint: bigint, name: string) { - if (bigint < 0) { - throw new ERR_OUT_OF_RANGE(name, ">= 0", bigint); - } + if (bigint < 0) { + throw new ERR_OUT_OF_RANGE(name, '>= 0', bigint); + } - const hex = bigint.toString(16); - const padded = hex.padStart(hex.length + (hex.length % 2), "0"); - return Buffer.from(padded, "hex"); + const hex = bigint.toString(16); + const padded = hex.padStart(hex.length + (hex.length % 2), '0'); + return Buffer.from(padded, 'hex'); } -function validateCandidate(candidate: PrimeNum): Buffer { - if (typeof candidate === "bigint") candidate = unsignedBigIntToBuffer(candidate, "candidate"); - if (!isAnyArrayBuffer(candidate) && !isArrayBufferView(candidate)) { - throw new ERR_INVALID_ARG_TYPE( - "candidate", - ["ArrayBuffer", "TypedArray", "Buffer", "DataView", "bigint"], - candidate - ); - } - return candidate as Buffer; +function validateCandidate(candidate: PrimeNum) : Buffer { + if (typeof candidate === 'bigint') + candidate = unsignedBigIntToBuffer(candidate, 'candidate'); + if (!isAnyArrayBuffer(candidate) && !isArrayBufferView(candidate)) { + throw new ERR_INVALID_ARG_TYPE( + 'candidate', + [ + 'ArrayBuffer', + 'TypedArray', + 'Buffer', + 'DataView', + 'bigint', + ], + candidate, + ); + } + return candidate as Buffer; } -function validateChecks(options: CheckPrimeOptions): number { - const { checks = 0 } = options; - // The checks option is unsigned but must fit into a signed 32-bit integer for OpenSSL. - validateInt32(checks, "options.checks", 0); - return checks; +function validateChecks(options : CheckPrimeOptions) : number { + const { + checks = 0, + } = options; + // The checks option is unsigned but must fit into a signed 32-bit integer for OpenSSL. + validateInt32(checks, 'options.checks', 0); + return checks; } export function checkPrimeSync(candidate: PrimeNum, options: CheckPrimeOptions = {}) { - candidate = validateCandidate(candidate); - validateObject(options, "options", {}); - const checks = validateChecks(options); - return cryptoImpl.checkPrimeSync(candidate as ArrayBufferView, checks); + candidate = validateCandidate(candidate); + validateObject(options, 'options', {}); + const checks = validateChecks(options); + return cryptoImpl.checkPrimeSync(candidate as ArrayBufferView, checks); } -export function checkPrime( - candidate: PrimeNum, - options: CheckPrimeOptions, - callback: CheckPrimeCallback -): void; -export function checkPrime(candidate: PrimeNum, callback: CheckPrimeCallback): void; -export function checkPrime( - candidate: PrimeNum, - options: CheckPrimeOptions | CheckPrimeCallback, - callback?: CheckPrimeCallback -): void { - candidate = validateCandidate(candidate); - if (typeof options === "function") { - callback = options; - options = {}; +export function checkPrime(candidate: PrimeNum, + options: CheckPrimeOptions, + callback: CheckPrimeCallback) : void; +export function checkPrime(candidate: PrimeNum, + callback: CheckPrimeCallback) : void; +export function checkPrime(candidate: PrimeNum, + options: CheckPrimeOptions|CheckPrimeCallback, + callback?: CheckPrimeCallback) : void { + candidate = validateCandidate(candidate); + if (typeof options === 'function') { + callback = options; + options = {}; + } + validateObject(options, 'options', {}); + validateFunction(callback, 'callback'); + const checks = validateChecks(options); + new Promise((res, rej) => { + try { + res(cryptoImpl.checkPrimeSync(candidate as ArrayBufferView, checks)); + } catch(err) { + rej(err); } - validateObject(options, "options", {}); - validateFunction(callback, "callback"); - const checks = validateChecks(options); - new Promise((res, rej) => { - try { - res(cryptoImpl.checkPrimeSync(candidate as ArrayBufferView, checks)); - } catch (err) { - rej(err); - } - }).then( - (val) => callback!(null, val), - (err) => callback!(err) - ); + }).then((val) => callback!(null, val), (err) => callback!(err)); } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_util.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_util.ts index 9b268df0b..5f52cdedc 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_util.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/crypto_util.ts @@ -1,48 +1,61 @@ /* eslint-disable */ -"use strict"; +'use strict'; -import { Buffer } from "./internal_buffer"; +import { + Buffer, +} from './internal_buffer'; -import { isAnyArrayBuffer, isArrayBufferView } from "./internal_types"; +import { + isAnyArrayBuffer, + isArrayBufferView, +} from './internal_types'; -import { ERR_INVALID_ARG_TYPE } from "./internal_errors"; +import { + ERR_INVALID_ARG_TYPE, +} from './internal_errors'; -import { validateString } from "./validators"; +import { + validateString, +} from './validators'; -import * as cryptoImpl from "./crypto"; +import * as cryptoImpl from './crypto'; type ArrayLike = cryptoImpl.ArrayLike; -export const kHandle = Symbol("kHandle"); -export const kFinalized = Symbol("kFinalized"); -export const kState = Symbol("kFinalized"); +export const kHandle = Symbol('kHandle'); +export const kFinalized = Symbol('kFinalized'); +export const kState = Symbol('kFinalized'); export function getStringOption(options: any, key: string) { - let value; - if (options && (value = options[key]) != null) validateString(value, `options.${key}`); - return value; + let value; + if (options && (value = options[key]) != null) + validateString(value, `options.${key}`); + return value; } -export function getArrayBufferOrView( - buffer: Buffer | ArrayBuffer | ArrayBufferView | string, - name: string, - encoding?: string -): Buffer | ArrayBuffer | ArrayBufferView { - if (isAnyArrayBuffer(buffer)) return buffer as ArrayBuffer; - if (typeof buffer === "string") { - if (encoding === undefined || encoding === "buffer") { - encoding = "utf8"; - } - return Buffer.from(buffer, encoding); +export function getArrayBufferOrView(buffer: Buffer | ArrayBuffer | ArrayBufferView | string, name: string, encoding?: string): Buffer | ArrayBuffer | ArrayBufferView { + if (isAnyArrayBuffer(buffer)) + return buffer as ArrayBuffer; + if (typeof buffer === 'string') { + if (encoding === undefined || encoding === 'buffer') { + encoding = 'utf8'; } - if (!isArrayBufferView(buffer)) { - throw new ERR_INVALID_ARG_TYPE( - name, - ["string", "ArrayBuffer", "Buffer", "TypedArray", "DataView"], - buffer - ); - } - return buffer; + return Buffer.from(buffer, encoding); + } + if (!isArrayBufferView(buffer)) { + throw new ERR_INVALID_ARG_TYPE( + name, + [ + 'string', + 'ArrayBuffer', + 'Buffer', + 'TypedArray', + 'DataView', + ], + buffer, + ); + } + return buffer; } /** @@ -58,45 +71,48 @@ export const numberToHexCharCode = (number: number): number => (number < 10 ? 48 * @return {bigint} */ export function arrayBufferToUnsignedBigInt(buf: ArrayBuffer): bigint { - const length = buf.byteLength; - const chars = Array(length * 2); - const view = new DataView(buf); - - for (let i = 0; i < length; i++) { - const val = view.getUint8(i); - chars[2 * i] = numberToHexCharCode(val >> 4); - chars[2 * i + 1] = numberToHexCharCode(val & 0xf); - } + const length = buf.byteLength; + const chars = Array(length * 2); + const view = new DataView(buf); + + for (let i = 0; i < length; i++) { + const val = view.getUint8(i); + chars[2 * i] = numberToHexCharCode(val >> 4); + chars[2 * i + 1] = numberToHexCharCode(val & 0xf); + } - return BigInt(`0x${String.fromCharCode.apply(null, chars)}`); + return BigInt(`0x${String.fromCharCode.apply(null, chars)}`); } // This is here because many functions accepted binary strings without // any explicit encoding in older versions of node, and we don't want // to break them unnecessarily. -export function toBuf(val: ArrayLike, encoding?: string): Buffer | ArrayBuffer | ArrayBufferView { - if (typeof val === "string") { - if (encoding === "buffer") { - encoding = "utf8"; - } - return Buffer.from(val, encoding); +export function toBuf(val: ArrayLike, encoding?: string): Buffer|ArrayBuffer|ArrayBufferView { + if (typeof val === 'string') { + if (encoding === 'buffer') { + encoding = 'utf8'; } - return val; + return Buffer.from(val, encoding); + } + return val; } -export function validateByteSource( - val: ArrayLike, - name: string -): Buffer | ArrayBuffer | ArrayBufferView { - val = toBuf(val); +export function validateByteSource(val: ArrayLike, + name: string): Buffer|ArrayBuffer|ArrayBufferView { + val = toBuf(val); - if (isAnyArrayBuffer(val) || isArrayBufferView(val)) { - return val; - } - - throw new ERR_INVALID_ARG_TYPE( - name, - ["string", "ArrayBuffer", "TypedArray", "DataView", "Buffer"], - val - ); + if (isAnyArrayBuffer(val) || isArrayBufferView(val)) { + return val; + } + + throw new ERR_INVALID_ARG_TYPE( + name, + [ + 'string', + 'ArrayBuffer', + 'TypedArray', + 'DataView', + 'Buffer', + ], + val); } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/events.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/events.ts index 83f86114d..f7b92a65d 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/events.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/events.ts @@ -1,12 +1,17 @@ import { - AbortError, - ERR_INVALID_ARG_TYPE, - ERR_INVALID_THIS, - ERR_OUT_OF_RANGE, - ERR_UNHANDLED_ERROR, + AbortError, + ERR_INVALID_ARG_TYPE, + ERR_INVALID_THIS, + ERR_OUT_OF_RANGE, + ERR_UNHANDLED_ERROR, } from "./internal_errors"; -import { validateAbortSignal, validateBoolean, validateFunction } from "./validators"; +import { + validateAbortSignal, + validateBoolean, + validateFunction, +} from "./validators"; + import * as process from "./process"; @@ -23,76 +28,78 @@ const kErrorMonitor = Symbol("events.errorMonitor"); const kMaxEventTargetListeners = Symbol("events.maxEventTargetListeners"); const kMaxEventTargetListenersWarned = Symbol("events.maxEventTargetListenersWarned"); + export interface EventEmitterOptions { - captureRejections?: boolean; -} + captureRejections? : boolean; +}; -export type EventName = string | symbol; +export type EventName = string|symbol; export type EventCallback = (...args: any[]) => unknown; export interface EventEmitter { - addListener(eventName: EventName, listener: EventCallback): EventEmitter; - emit(eventName: EventName, ...args: unknown[]): void; - eventNames(): EventName[]; - getMaxListeners(): number; - listenerCount(eventName: EventName): number; - listeners(eventName: EventName): EventCallback[]; - off(eventName: EventName, listener: EventCallback): EventEmitter; - on(eventName: EventName, listener: EventCallback): EventEmitter; - once(eventName: EventName, listener: EventCallback): EventEmitter; - prependListener(eventName: EventName, listener: EventCallback): EventEmitter; - prependOnceListener(eventName: EventName, listener: EventCallback): EventEmitter; - removeAllListeners(eventName?: EventName): EventEmitter; - removeListener(eventName: EventName, listener: EventCallback): EventEmitter; - setMaxListeners(n: number): EventEmitter; - rawListeners(eventName: EventName): EventCallback[]; - [kRejection](err: unknown, eventName: EventName, ...args: unknown[]): void; -} + addListener(eventName: EventName, listener: EventCallback): EventEmitter; + emit(eventName: EventName, ...args: unknown[]): void; + eventNames() : EventName[]; + getMaxListeners(): number; + listenerCount(eventName: EventName): number; + listeners(eventName: EventName): EventCallback[]; + off(eventName: EventName, listener: EventCallback): EventEmitter; + on(eventName: EventName, listener: EventCallback): EventEmitter; + once(eventName: EventName, listener: EventCallback): EventEmitter; + prependListener(eventName: EventName, listener: EventCallback): EventEmitter; + prependOnceListener(eventName: EventName, listener: EventCallback): EventEmitter; + removeAllListeners(eventName?: EventName): EventEmitter; + removeListener(eventName: EventName, listener: EventCallback): EventEmitter; + setMaxListeners(n: number): EventEmitter; + rawListeners(eventName: EventName): EventCallback[]; + [kRejection](err: unknown, eventName: EventName, ...args: unknown[]) : void; +}; type AsyncResource = typeof AsyncResource; -declare var EventTarget: Function; +declare var EventTarget : Function; -export function EventEmitter(this: EventEmitter, opts?: EventEmitterOptions) { - EventEmitter.init.call(this, opts); +export function EventEmitter(this : EventEmitter, opts? : EventEmitterOptions) { + EventEmitter.init.call(this, opts); } class EventEmitterReferencingAsyncResource extends AsyncResource { - #eventEmitter: EventEmitter; - constructor(emitter: EventEmitter) { - super(""); - this.#eventEmitter = emitter; - } - - get eventEmitter() { - if (this.#eventEmitter === undefined) - throw new ERR_INVALID_THIS("EventEmitterReferencingAsyncResource"); - return this.#eventEmitter; - } + #eventEmitter : EventEmitter; + constructor(emitter : EventEmitter) { + super(''); + this.#eventEmitter = emitter; + } + + get eventEmitter() { + if (this.#eventEmitter === undefined) + throw new ERR_INVALID_THIS('EventEmitterReferencingAsyncResource'); + return this.#eventEmitter; + } } // @ts-ignore -- TODO(soon) Properly handle the extends EventEmitter here export class EventEmitterAsyncResource extends EventEmitter { - #asyncResource: EventEmitterReferencingAsyncResource; - - constructor(options?: EventEmitterOptions) { - super(options); - // @ts-ignore - this.#asyncResource = new EventEmitterReferencingAsyncResource(this); - } - - get asyncResource(): AsyncResource { - if (this.#asyncResource === undefined) - throw new ERR_INVALID_THIS("EventEmitterAsyncResource"); - // @ts-ignore - return this.#asyncResource; - } - - emit(event: string | symbol, ...args: any[]): void { - if (this.#asyncResource === undefined) - throw new ERR_INVALID_THIS("EventEmitterAsyncResource"); - args.unshift(super.emit, this, event); - Reflect.apply(this.#asyncResource.runInAsyncScope, this.#asyncResource, args); - } + #asyncResource : EventEmitterReferencingAsyncResource; + + constructor(options? : EventEmitterOptions) { + super(options); + // @ts-ignore + this.#asyncResource = new EventEmitterReferencingAsyncResource(this); + } + + get asyncResource() : AsyncResource { + if (this.#asyncResource === undefined) + throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); + // @ts-ignore + return this.#asyncResource; + } + + emit(event : string | symbol, ...args : any[]) : void { + if (this.#asyncResource === undefined) + throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); + args.unshift(super.emit, this, event); + Reflect.apply(this.#asyncResource.runInAsyncScope, + this.#asyncResource, args); + } } export default EventEmitter; @@ -112,777 +119,786 @@ export const errorMonitor = EventEmitter.errorMonitor; export let defaultMaxListeners = 10; Object.defineProperties(EventEmitter, { - captureRejections: { - get() { - return EventEmitter.prototype[kCapture]; - }, - set(value) { - validateBoolean(value, "EventEmitter.captureRejections"); - - EventEmitter.prototype[kCapture] = value; - }, - enumerable: true, + captureRejections: { + get() { + return EventEmitter.prototype[kCapture]; }, - defaultMaxListeners: { - enumerable: true, - get: function () { - return defaultMaxListeners; - }, - set: function (arg) { - if (typeof arg !== "number" || arg < 0 || Number.isNaN(arg)) { - throw new ERR_OUT_OF_RANGE("defaultMaxListeners", "a non-negative number", arg); - } - defaultMaxListeners = arg; - }, + set(value) { + validateBoolean(value, "EventEmitter.captureRejections"); + + EventEmitter.prototype[kCapture] = value; }, - kMaxEventTargetListeners: { - value: kMaxEventTargetListeners, - enumerable: false, - configurable: false, - writable: false, + enumerable: true, + }, + defaultMaxListeners: { + enumerable: true, + get: function () { + return defaultMaxListeners; }, - kMaxEventTargetListenersWarned: { - value: kMaxEventTargetListenersWarned, - enumerable: false, - configurable: false, - writable: false, + set: function (arg) { + if (typeof arg !== "number" || arg < 0 || Number.isNaN(arg)) { + throw new ERR_OUT_OF_RANGE( + "defaultMaxListeners", + "a non-negative number", + arg, + ); + } + defaultMaxListeners = arg; }, + }, + kMaxEventTargetListeners: { + value: kMaxEventTargetListeners, + enumerable: false, + configurable: false, + writable: false, + }, + kMaxEventTargetListenersWarned: { + value: kMaxEventTargetListenersWarned, + enumerable: false, + configurable: false, + writable: false, + }, }); // The default for captureRejections is false Object.defineProperty(EventEmitter.prototype, kCapture, { - value: false, - writable: true, - enumerable: false, + value: false, + writable: true, + enumerable: false, }); -EventEmitter.init = function (this: any, opts?: EventEmitterOptions) { - if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) { - this._events = Object.create(null); - this._eventsCount = 0; - } - - (this as any)._maxListeners ??= undefined; - - if (opts?.captureRejections) { - validateBoolean(opts.captureRejections, "options.captureRejections"); - (this as any)[kCapture] = Boolean(opts.captureRejections); - } else { - // Assigning the kCapture property directly saves an expensive - // prototype lookup in a very sensitive hot path. - (this as any)[kCapture] = EventEmitter.prototype[kCapture]; - } +EventEmitter.init = function (this: any, opts? : EventEmitterOptions) { + if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + (this as any)._maxListeners ??= undefined; + + if (opts?.captureRejections) { + validateBoolean(opts.captureRejections, "options.captureRejections"); + (this as any)[kCapture] = Boolean(opts.captureRejections); + } else { + // Assigning the kCapture property directly saves an expensive + // prototype lookup in a very sensitive hot path. + (this as any)[kCapture] = EventEmitter.prototype[kCapture]; + } }; -export function setMaxListeners(n = defaultMaxListeners, ...eventTargets: any[]) { - if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { - throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); - } - if (eventTargets.length === 0) { - defaultMaxListeners = n; - } else { - for (let i = 0; i < eventTargets.length; i++) { - const target = eventTargets[i]; - if (target instanceof EventTarget) { - (target as any)[kMaxEventTargetListeners] = n; - (target as any)[kMaxEventTargetListenersWarned] = false; - } else if (typeof target.setMaxListeners === "function") { - target.setMaxListeners(n); - } else { - throw new ERR_INVALID_ARG_TYPE( - "eventTargets", - ["EventEmitter", "EventTarget"], - target - ); - } - } +export function setMaxListeners( + n = defaultMaxListeners, + ...eventTargets : any[]) { + if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { + throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); + } + if (eventTargets.length === 0) { + defaultMaxListeners = n; + } else { + for (let i = 0; i < eventTargets.length; i++) { + const target = eventTargets[i]; + if (target instanceof EventTarget) { + (target as any)[kMaxEventTargetListeners] = n; + (target as any)[kMaxEventTargetListenersWarned] = false; + } else if (typeof target.setMaxListeners === "function") { + target.setMaxListeners(n); + } else { + throw new ERR_INVALID_ARG_TYPE( + "eventTargets", + ["EventEmitter", "EventTarget"], + target, + ); + } } + } } EventEmitter.prototype._events = undefined; EventEmitter.prototype._eventsCount = 0; EventEmitter.prototype._maxListeners = undefined; -function addCatch(that: any, promise: Promise, type: string | symbol, args: any[]) { - if (!that[kCapture]) { - return; - } - - // Handle Promises/A+ spec, then could be a getter - // that throws on second use. - try { - const then = promise.then; - - if (typeof then === "function") { - then.call(promise, undefined, function (err) { - // The callback is called with nextTick to avoid a follow-up - // rejection from this promise. - process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args); - }); - } - } catch (err) { - that.emit("error", err); - } +function addCatch(that : any, promise : Promise, type : string | symbol, args : any[]) { + if (!that[kCapture]) { + return; + } + + // Handle Promises/A+ spec, then could be a getter + // that throws on second use. + try { + const then = promise.then; + + if (typeof then === "function") { + then.call(promise, undefined, function (err) { + // The callback is called with nextTick to avoid a follow-up + // rejection from this promise. + process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args); + }); + } + } catch (err) { + that.emit("error", err); + } } -function emitUnhandledRejectionOrErr(ee: any, err: any, type: string | symbol, args: any[]) { - if (typeof ee[kRejection] === "function") { - ee[kRejection](err, type, ...args); - } else { - // We have to disable the capture rejections mechanism, otherwise - // we might end up in an infinite loop. - const prev = ee[kCapture]; - - // If the error handler throws, it is not catcheable and it - // will end up in 'uncaughtException'. We restore the previous - // value of kCapture in case the uncaughtException is present - // and the exception is handled. - try { - ee[kCapture] = false; - ee.emit("error", err); - } finally { - ee[kCapture] = prev; - } +function emitUnhandledRejectionOrErr(ee : any, err : any, type: string | symbol, args : any[]) { + if (typeof ee[kRejection] === "function") { + ee[kRejection](err, type, ...args); + } else { + // We have to disable the capture rejections mechanism, otherwise + // we might end up in an infinite loop. + const prev = ee[kCapture]; + + // If the error handler throws, it is not catcheable and it + // will end up in 'uncaughtException'. We restore the previous + // value of kCapture in case the uncaughtException is present + // and the exception is handled. + try { + ee[kCapture] = false; + ee.emit("error", err); + } finally { + ee[kCapture] = prev; } + } } -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n: number) { - if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { - throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); - } - this._maxListeners = n; - return this; +EventEmitter.prototype.setMaxListeners = function setMaxListeners(n : number) { + if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { + throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); + } + this._maxListeners = n; + return this; }; -function _getMaxListeners(that: any) { - if (that._maxListeners === undefined) { - return (EventEmitter as any).defaultMaxListeners; - } - return that._maxListeners; +function _getMaxListeners(that : any) { + if (that._maxListeners === undefined) { + return (EventEmitter as any).defaultMaxListeners; + } + return that._maxListeners; } EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return _getMaxListeners(this); + return _getMaxListeners(this); }; -EventEmitter.prototype.emit = function emit(type: string | symbol, ...args: any[]) { - let doError = type === "error"; - - const events = this._events; - if (events !== undefined) { - if (doError && events[kErrorMonitor] !== undefined) { - this.emit(kErrorMonitor, ...args); - } - doError = doError && events.error === undefined; - } else if (!doError) { - return false; - } +EventEmitter.prototype.emit = function emit(type : string | symbol, ...args: any[]) { + let doError = type === "error"; - // If there is no 'error' event listener then throw. - if (doError) { - let er; - if (args.length > 0) { - er = args[0]; - } - if (er instanceof Error) { - try { - const capture = {}; - (Error as any).captureStackTrace(capture, EventEmitter.prototype.emit); - } catch { - // pass - } - - // Note: The comments on the `throw` lines are intentional, they show - // up in Node's output if this results in an unhandled exception. - throw er; // Unhandled 'error' event - } - - let stringifiedEr; - try { - stringifiedEr = inspect(er); - } catch { - stringifiedEr = er; - } - - // At least give some kind of context to the user - const err = new ERR_UNHANDLED_ERROR(stringifiedEr); - (err as any).context = er; - throw err; // Unhandled 'error' event + const events = this._events; + if (events !== undefined) { + if (doError && events[kErrorMonitor] !== undefined) { + this.emit(kErrorMonitor, ...args); } + doError = doError && events.error === undefined; + } else if (!doError) { + return false; + } - const handler = events[type]; - - if (handler === undefined) { - return false; + // If there is no 'error' event listener then throw. + if (doError) { + let er; + if (args.length > 0) { + er = args[0]; } + if (er instanceof Error) { + try { + const capture = {}; + (Error as any).captureStackTrace(capture, EventEmitter.prototype.emit); + } catch { + // pass + } - if (typeof handler === "function") { - const result = handler.apply(this, args); - - // We check if result is undefined first because that - // is the most common case so we do not pay any perf - // penalty - if (result !== undefined && result !== null) { - addCatch(this, result, type, args); - } - } else { - const len = handler.length; - const listeners = arrayClone(handler); - for (let i = 0; i < len; ++i) { - const result = listeners[i].apply(this, args); - - // We check if result is undefined first because that - // is the most common case so we do not pay any perf - // penalty. - // This code is duplicated because extracting it away - // would make it non-inlineable. - if (result !== undefined && result !== null) { - addCatch(this, result, type, args); - } - } + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event } - return true; + let stringifiedEr; + try { + stringifiedEr = inspect(er); + } catch { + stringifiedEr = er; + } + + // At least give some kind of context to the user + const err = new ERR_UNHANDLED_ERROR(stringifiedEr); + (err as any).context = er; + throw err; // Unhandled 'error' event + } + + const handler = events[type]; + + if (handler === undefined) { + return false; + } + + if (typeof handler === "function") { + const result = handler.apply(this, args); + + // We check if result is undefined first because that + // is the most common case so we do not pay any perf + // penalty + if (result !== undefined && result !== null) { + addCatch(this, result, type, args); + } + } else { + const len = handler.length; + const listeners = arrayClone(handler); + for (let i = 0; i < len; ++i) { + const result = listeners[i].apply(this, args); + + // We check if result is undefined first because that + // is the most common case so we do not pay any perf + // penalty. + // This code is duplicated because extracting it away + // would make it non-inlineable. + if (result !== undefined && result !== null) { + addCatch(this, result, type, args); + } + } + } + + return true; }; -function _addListener(target: any, type: string | symbol, listener: unknown, prepend: boolean) { - let m; - let events; - let existing; - - validateFunction(listener, "listener"); - - events = target._events; - if (events === undefined) { - events = target._events = Object.create(null); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener !== undefined) { - target.emit("newListener", type, (listener as any).listener ?? listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (existing === undefined) { - // Optimize the case of one listener. Don't need the extra array object. - events[type] = listener; - ++target._eventsCount; +function _addListener(target : any, type : string | symbol, listener : unknown, prepend : boolean) { + let m; + let events; + let existing; + + validateFunction(listener, "listener"); + + events = target._events; + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit("newListener", type, (listener as any).listener ?? listener); + + // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + events = target._events; + } + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === "function") { + // Adding the second element, need to change to array. + existing = events[type] = prepend + ? [listener, existing] + : [existing, listener]; + // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); } else { - if (typeof existing === "function") { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : [existing, listener]; - // If we've already got an array, just append. - } else if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - - // Check for listener leak - m = _getMaxListeners(target); - if (m > 0 && existing.length > m && !existing.warned) { - existing.warned = true; - console.log( - "Possible EventEmitter memory leak detected. " + - `${existing.length} ${String(type)} listeners ` + - `added to an EventEmitter. Use ` + - "emitter.setMaxListeners() to increase limit" - ); - // TODO(soon): Implement process.emitWarning and inspect - // // No error code for this since it is a Warning - // // eslint-disable-next-line no-restricted-syntax - // const w = new Error( - // "Possible EventEmitter memory leak detected. " + - // `${existing.length} ${String(type)} listeners ` + - // `added to ${inspect(target, { depth: -1 })}. Use ` + - // "emitter.setMaxListeners() to increase limit", - // ); - // w.name = "MaxListenersExceededWarning"; - // w.emitter = target; - // w.type = type; - // w.count = existing.length; - // process.emitWarning(w); - } - } - - return target; + existing.push(listener); + } + + // Check for listener leak + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + console.log( + "Possible EventEmitter memory leak detected. " + + `${existing.length} ${String(type)} listeners ` + + `added to an EventEmitter. Use ` + + "emitter.setMaxListeners() to increase limit", + ); + // TODO(soon): Implement process.emitWarning and inspect + // // No error code for this since it is a Warning + // // eslint-disable-next-line no-restricted-syntax + // const w = new Error( + // "Possible EventEmitter memory leak detected. " + + // `${existing.length} ${String(type)} listeners ` + + // `added to ${inspect(target, { depth: -1 })}. Use ` + + // "emitter.setMaxListeners() to increase limit", + // ); + // w.name = "MaxListenersExceededWarning"; + // w.emitter = target; + // w.type = type; + // w.count = existing.length; + // process.emitWarning(w); + } + } + + return target; } -EventEmitter.prototype.addListener = function addListener( - type: string | symbol, - listener: unknown -) { - return _addListener(this, type, listener, false); +EventEmitter.prototype.addListener = function addListener(type : string | symbol, listener : unknown) { + return _addListener(this, type, listener, false); }; EventEmitter.prototype.on = EventEmitter.prototype.addListener; EventEmitter.prototype.prependListener = function prependListener( - type: string | symbol, - listener: unknown + type : string | symbol, + listener : unknown, ) { - return _addListener(this, type, listener, true); + return _addListener(this, type, listener, true); }; function onceWrapper(this: any) { - if (!this.fired) { - this.target.removeListener(this.type, this.wrapFn); - this.fired = true; - if (arguments.length === 0) { - return this.listener.call(this.target); - } - return this.listener.apply(this.target, arguments); + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) { + return this.listener.call(this.target); } + return this.listener.apply(this.target, arguments); + } } -function _onceWrap(target: any, type: string | symbol, listener: unknown) { - const state = { fired: false, wrapFn: undefined, target, type, listener }; - const wrapped = onceWrapper.bind(state); - (wrapped as any).listener = listener; - (state as any).wrapFn = wrapped; - return wrapped; +function _onceWrap(target : any, type : string | symbol, listener : unknown) { + const state = { fired: false, wrapFn: undefined, target, type, listener }; + const wrapped = onceWrapper.bind(state); + (wrapped as any).listener = listener; + (state as any).wrapFn = wrapped; + return wrapped; } -EventEmitter.prototype.once = function once(type: string | symbol, listener: unknown) { - validateFunction(listener, "listener"); +EventEmitter.prototype.once = function once(type : string | symbol, listener : unknown) { + validateFunction(listener, "listener"); - this.on(type, _onceWrap(this, type, listener)); - return this; + this.on(type, _onceWrap(this, type, listener)); + return this; }; EventEmitter.prototype.prependOnceListener = function prependOnceListener( - type: string | symbol, - listener: unknown + type : string | symbol, + listener : unknown, ) { - validateFunction(listener, "listener"); + validateFunction(listener, "listener"); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; + this.prependListener(type, _onceWrap(this, type, listener)); + return this; }; EventEmitter.prototype.removeListener = function removeListener( - type: string | symbol, - listener: unknown + type : string | symbol, + listener : unknown, ) { - validateFunction(listener, "listener"); + validateFunction(listener, "listener"); - const events = this._events; - if (events === undefined) { - return this; - } + const events = this._events; + if (events === undefined) { + return this; + } + + const list = events[type]; + if (list === undefined) { + return this; + } - const list = events[type]; - if (list === undefined) { - return this; + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) { + this._events = Object.create(null); + } else { + delete events[type]; + if (events.removeListener) { + this.emit("removeListener", type, list.listener || listener); + } } + } else if (typeof list !== "function") { + let position = -1; - if (list === listener || list.listener === listener) { - if (--this._eventsCount === 0) { - this._events = Object.create(null); - } else { - delete events[type]; - if (events.removeListener) { - this.emit("removeListener", type, list.listener || listener); - } - } - } else if (typeof list !== "function") { - let position = -1; - - for (let i = list.length - 1; i >= 0; i--) { - if (list[i] === listener || list[i].listener === listener) { - position = i; - break; - } - } - - if (position < 0) { - return this; - } - - if (position === 0) { - list.shift(); - } else { - spliceOne(list, position); - } - - if (list.length === 1) { - events[type] = list[0]; - } - - if (events.removeListener !== undefined) { - this.emit("removeListener", type, listener); - } + for (let i = list.length - 1; i >= 0; i--) { + if (list[i] === listener || list[i].listener === listener) { + position = i; + break; + } } - return this; -}; + if (position < 0) { + return this; + } -EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + if (position === 0) { + list.shift(); + } else { + spliceOne(list, position); + } -EventEmitter.prototype.removeAllListeners = function removeAllListeners(type: string | symbol) { - const events = this._events; - if (events === undefined) { - return this; + if (list.length === 1) { + events[type] = list[0]; } - // Not listening for removeListener, no need to emit - if (events.removeListener === undefined) { - if (arguments.length === 0) { - this._events = Object.create(null); - this._eventsCount = 0; - } else if (events[type] !== undefined) { - if (--this._eventsCount === 0) { - this._events = Object.create(null); - } else { - delete events[type]; - } - } - return this; + if (events.removeListener !== undefined) { + this.emit("removeListener", type, listener); } + } - // Emit removeListener for all listeners on all events + return this; +}; + +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + +EventEmitter.prototype.removeAllListeners = function removeAllListeners(type : string | symbol) { + const events = this._events; + if (events === undefined) { + return this; + } + + // Not listening for removeListener, no need to emit + if (events.removeListener === undefined) { if (arguments.length === 0) { - for (const key of Reflect.ownKeys(events)) { - if (key === "removeListener") continue; - this.removeAllListeners(key); - } - this.removeAllListeners("removeListener"); + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) { this._events = Object.create(null); - this._eventsCount = 0; - return this; + } else { + delete events[type]; + } + } + return this; + } + + // Emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (const key of Reflect.ownKeys(events)) { + if (key === "removeListener") continue; + this.removeAllListeners(key); } + this.removeAllListeners("removeListener"); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } - const listeners = events[type]; + const listeners = events[type]; - if (typeof listeners === "function") { - this.removeListener(type, listeners); - } else if (listeners !== undefined) { - // LIFO order - for (let i = listeners.length - 1; i >= 0; i--) { - this.removeListener(type, listeners[i]); - } + if (typeof listeners === "function") { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (let i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); } + } - return this; + return this; }; -function _listeners(target: any, type: string | symbol, unwrap: boolean) { - const events = target._events; +function _listeners(target : any, type : string | symbol, unwrap : boolean) { + const events = target._events; - if (events === undefined) { - return []; - } + if (events === undefined) { + return []; + } - const evlistener = events[type]; - if (evlistener === undefined) { - return []; - } + const evlistener = events[type]; + if (evlistener === undefined) { + return []; + } - if (typeof evlistener === "function") { - return unwrap ? [evlistener.listener || evlistener] : [evlistener]; - } + if (typeof evlistener === "function") { + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + } - return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener); + return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener); } -EventEmitter.prototype.listeners = function listeners(type: string | symbol) { - return _listeners(this, type, true); +EventEmitter.prototype.listeners = function listeners(type : string | symbol) { + return _listeners(this, type, true); }; -EventEmitter.prototype.rawListeners = function rawListeners(type: string | symbol) { - return _listeners(this, type, false); +EventEmitter.prototype.rawListeners = function rawListeners(type : string | symbol) { + return _listeners(this, type, false); }; -const _listenerCount = function listenerCount(this: any, type: string | symbol) { - const events = this._events; +const _listenerCount = function listenerCount(this : any, type : string | symbol) { + const events = this._events; - if (events !== undefined) { - const evlistener = events[type]; + if (events !== undefined) { + const evlistener = events[type]; - if (typeof evlistener === "function") { - return 1; - } else if (evlistener !== undefined) { - return evlistener.length; - } + if (typeof evlistener === "function") { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; } + } - return 0; + return 0; }; EventEmitter.prototype.listenerCount = _listenerCount; -export function listenerCount(emitter: any, type: string | symbol) { - if (typeof emitter.listenerCount === "function") { - return emitter.listenerCount(type); - } - return _listenerCount.call(emitter, type); +export function listenerCount(emitter : any, type : string | symbol) { + if (typeof emitter.listenerCount === "function") { + return emitter.listenerCount(type); + } + return _listenerCount.call(emitter, type); } EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; + return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; }; -function arrayClone(arr: any[]) { - // At least since V8 8.3, this implementation is faster than the previous - // which always used a simple for-loop - switch (arr.length) { - case 2: - return [arr[0], arr[1]]; - case 3: - return [arr[0], arr[1], arr[2]]; - case 4: - return [arr[0], arr[1], arr[2], arr[3]]; - case 5: - return [arr[0], arr[1], arr[2], arr[3], arr[4]]; - case 6: - return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]]; - } - return arr.slice(); +function arrayClone(arr : any[]) { + // At least since V8 8.3, this implementation is faster than the previous + // which always used a simple for-loop + switch (arr.length) { + case 2: + return [arr[0], arr[1]]; + case 3: + return [arr[0], arr[1], arr[2]]; + case 4: + return [arr[0], arr[1], arr[2], arr[3]]; + case 5: + return [arr[0], arr[1], arr[2], arr[3], arr[4]]; + case 6: + return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]]; + } + return arr.slice(); } -function unwrapListeners(arr: any[]) { - const ret = arrayClone(arr); - for (let i = 0; i < ret.length; ++i) { - const orig = ret[i].listener; - if (typeof orig === "function") { - ret[i] = orig; - } +function unwrapListeners(arr : any[]) { + const ret = arrayClone(arr); + for (let i = 0; i < ret.length; ++i) { + const orig = ret[i].listener; + if (typeof orig === "function") { + ret[i] = orig; } - return ret; + } + return ret; } -export function getEventListeners(emitterOrTarget: any, type: string | symbol) { - // First check if EventEmitter - if (typeof emitterOrTarget.listeners === "function") { - return emitterOrTarget.listeners(type); - } - if (emitterOrTarget instanceof EventTarget) { - // Workers does not implement the ability to get the event listeners on an - // EventTarget the way that Node.js does. We simply return empty here. - return []; - } - throw new ERR_INVALID_ARG_TYPE("emitter", ["EventEmitter", "EventTarget"], emitterOrTarget); +export function getEventListeners(emitterOrTarget : any, type : string | symbol) { + // First check if EventEmitter + if (typeof emitterOrTarget.listeners === "function") { + return emitterOrTarget.listeners(type); + } + if (emitterOrTarget instanceof EventTarget) { + // Workers does not implement the ability to get the event listeners on an + // EventTarget the way that Node.js does. We simply return empty here. + return []; + } + throw new ERR_INVALID_ARG_TYPE( + "emitter", + ["EventEmitter", "EventTarget"], + emitterOrTarget, + ); } export interface OnceOptions { - signal?: AbortSignal; -} + signal?: AbortSignal; +}; -export async function once(emitter: any, name: string | symbol, options: OnceOptions = {}) { - const signal = options?.signal; - validateAbortSignal(signal, "options.signal"); - if (signal?.aborted) { - throw new AbortError(); +export async function once(emitter : any, name : string | symbol, options : OnceOptions = {}) { + const signal = options?.signal; + validateAbortSignal(signal, "options.signal"); + if (signal?.aborted) { + throw new AbortError(); + } + return new Promise((resolve, reject) => { + const errorListener = (err : any) => { + emitter.removeListener(name, resolver); + if (signal != null) { + eventTargetAgnosticRemoveListener(signal, "abort", abortListener); + } + reject(err); + }; + const resolver = (...args : any[]) => { + if (typeof emitter.removeListener === "function") { + emitter.removeListener("error", errorListener); + } + if (signal != null) { + eventTargetAgnosticRemoveListener(signal, "abort", abortListener); + } + resolve(args); + }; + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== "error" && typeof emitter.once === "function") { + emitter.once("error", errorListener); } - return new Promise((resolve, reject) => { - const errorListener = (err: any) => { - emitter.removeListener(name, resolver); - if (signal != null) { - eventTargetAgnosticRemoveListener(signal, "abort", abortListener); - } - reject(err); - }; - const resolver = (...args: any[]) => { - if (typeof emitter.removeListener === "function") { - emitter.removeListener("error", errorListener); - } - if (signal != null) { - eventTargetAgnosticRemoveListener(signal, "abort", abortListener); - } - resolve(args); - }; - eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); - if (name !== "error" && typeof emitter.once === "function") { - emitter.once("error", errorListener); - } - function abortListener() { - eventTargetAgnosticRemoveListener(emitter, name, resolver); - eventTargetAgnosticRemoveListener(emitter, "error", errorListener); - reject(new AbortError()); - } - if (signal != null) { - eventTargetAgnosticAddListener(signal, "abort", abortListener, { once: true }); - } - }); + function abortListener() { + eventTargetAgnosticRemoveListener(emitter, name, resolver); + eventTargetAgnosticRemoveListener(emitter, "error", errorListener); + reject(new AbortError()); + } + if (signal != null) { + eventTargetAgnosticAddListener( + signal, + "abort", + abortListener, + { once: true }, + ); + } + }); } const AsyncIteratorPrototype = Object.getPrototypeOf( - Object.getPrototypeOf(async function* () {}).prototype + Object.getPrototypeOf(async function* () {}).prototype, ); function createIterResult(value: any, done: boolean) { - return { value, done }; + return { value, done }; } -function eventTargetAgnosticRemoveListener( - emitter: any, - name: string | symbol, - listener: unknown, - flags: unknown = undefined -) { - if (typeof emitter.removeListener === "function") { - emitter.removeListener(name, listener); - } else if (typeof emitter.removeEventListener === "function") { - emitter.removeEventListener(name, listener, flags); - } else { - throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); - } +function eventTargetAgnosticRemoveListener(emitter : any, name : string | symbol, listener : unknown, flags : unknown = undefined) { + if (typeof emitter.removeListener === "function") { + emitter.removeListener(name, listener); + } else if (typeof emitter.removeEventListener === "function") { + emitter.removeEventListener(name, listener, flags); + } else { + throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); + } } interface AddListenerFlags { - once?: boolean; + once? : boolean; } -function eventTargetAgnosticAddListener( - emitter: any, - name: string | symbol, - listener: unknown, - flags: AddListenerFlags = {} -) { - if (typeof emitter.on === "function") { - if (flags?.once) { - emitter.once(name, listener); - } else { - emitter.on(name, listener); - } - } else if (typeof emitter.addEventListener === "function") { - // EventTarget does not have `error` event semantics like Node - // EventEmitters, we do not listen to `error` events here. - emitter.addEventListener( - name, - (arg: unknown) => { - (listener as any)(arg); - }, - flags - ); +function eventTargetAgnosticAddListener(emitter : any, name : string | symbol, listener : unknown, flags : AddListenerFlags = {}) { + if (typeof emitter.on === "function") { + if (flags?.once) { + emitter.once(name, listener); } else { - throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); - } + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === "function") { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we do not listen to `error` events here. + emitter.addEventListener(name, (arg : unknown) => { + (listener as any)(arg); + }, flags); + } else { + throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); + } } interface OnOptions { - signal?: AbortSignal; + signal?: AbortSignal; } -export function on(emitter: any, event: string | symbol, options: OnOptions = {}) { - const signal = options?.signal; - validateAbortSignal(signal, "options.signal"); - if (signal?.aborted) { - throw new AbortError(); - } +export function on(emitter : any, event : string | symbol, options : OnOptions = {}) { + const signal = options?.signal; + validateAbortSignal(signal, "options.signal"); + if (signal?.aborted) { + throw new AbortError(); + } + + const unconsumedEvents : any[] = []; + const unconsumedPromises : any[] = []; + let error : any = null; + let finished = false; + + const iterator = Object.setPrototypeOf({ + next() { + // First, we consume all unread events + const value = unconsumedEvents.shift(); + if (value) { + return Promise.resolve(createIterResult(value, false)); + } + + // Then we error, if an error happened + // This happens one time if at all, because after 'error' + // we stop listening + if (error) { + const p = Promise.reject(error); + // Only the first element errors + error = null; + return p; + } + + // If the iterator is finished, resolve to done + if (finished) { + return Promise.resolve(createIterResult(undefined, true)); + } + + // Wait until an event happens + return new Promise(function (resolve, reject) { + unconsumedPromises.push({ resolve, reject }); + }); + }, - const unconsumedEvents: any[] = []; - const unconsumedPromises: any[] = []; - let error: any = null; - let finished = false; - - const iterator = Object.setPrototypeOf( - { - next() { - // First, we consume all unread events - const value = unconsumedEvents.shift(); - if (value) { - return Promise.resolve(createIterResult(value, false)); - } - - // Then we error, if an error happened - // This happens one time if at all, because after 'error' - // we stop listening - if (error) { - const p = Promise.reject(error); - // Only the first element errors - error = null; - return p; - } - - // If the iterator is finished, resolve to done - if (finished) { - return Promise.resolve(createIterResult(undefined, true)); - } - - // Wait until an event happens - return new Promise(function (resolve, reject) { - unconsumedPromises.push({ resolve, reject }); - }); - }, - - return() { - eventTargetAgnosticRemoveListener(emitter, event, eventHandler); - eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); - - if (signal) { - eventTargetAgnosticRemoveListener(signal, "abort", abortListener, { - once: true, - }); - } - - finished = true; - - for (const promise of unconsumedPromises) { - promise.resolve(createIterResult(undefined, true)); - } - - return Promise.resolve(createIterResult(undefined, true)); - }, - - throw(err: any) { - if (!err || !(err instanceof Error)) { - throw new ERR_INVALID_ARG_TYPE("EventEmitter.AsyncIterator", "Error", err); - } - error = err; - eventTargetAgnosticRemoveListener(emitter, event, eventHandler); - eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); - }, - - [Symbol.asyncIterator]() { - return this; - }, - }, - AsyncIteratorPrototype - ); + return() { + eventTargetAgnosticRemoveListener(emitter, event, eventHandler); + eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); - eventTargetAgnosticAddListener(emitter, event, eventHandler); - if (event !== "error" && typeof emitter.on === "function") { - emitter.on("error", errorHandler); - } + if (signal) { + eventTargetAgnosticRemoveListener( + signal, + "abort", + abortListener, + { once: true }, + ); + } - if (signal) { - eventTargetAgnosticAddListener(signal, "abort", abortListener, { once: true }); - } + finished = true; - return iterator; + for (const promise of unconsumedPromises) { + promise.resolve(createIterResult(undefined, true)); + } - function abortListener() { - errorHandler(new AbortError()); - } + return Promise.resolve(createIterResult(undefined, true)); + }, - function eventHandler(...args: any[]) { - const promise = unconsumedPromises.shift(); - if (promise) { - promise.resolve(createIterResult(args, false)); - } else { - unconsumedEvents.push(args); - } - } + throw(err : any) { + if (!err || !(err instanceof Error)) { + throw new ERR_INVALID_ARG_TYPE( + "EventEmitter.AsyncIterator", + "Error", + err, + ); + } + error = err; + eventTargetAgnosticRemoveListener(emitter, event, eventHandler); + eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); + }, + + [Symbol.asyncIterator]() { + return this; + }, + }, AsyncIteratorPrototype); + + eventTargetAgnosticAddListener(emitter, event, eventHandler); + if (event !== "error" && typeof emitter.on === "function") { + emitter.on("error", errorHandler); + } + + if (signal) { + eventTargetAgnosticAddListener( + signal, + "abort", + abortListener, + { once: true }, + ); + } + + return iterator; - function errorHandler(err: any) { - finished = true; + function abortListener() { + errorHandler(new AbortError()); + } - const toError = unconsumedPromises.shift(); + function eventHandler(...args : any[]) { + const promise = unconsumedPromises.shift(); + if (promise) { + promise.resolve(createIterResult(args, false)); + } else { + unconsumedEvents.push(args); + } + } - if (toError) { - toError.reject(err); - } else { - // The next time we call next() - error = err; - } + function errorHandler(err : any) { + finished = true; - iterator.return(); + const toError = unconsumedPromises.shift(); + + if (toError) { + toError.reject(err); + } else { + // The next time we call next() + error = err; } + + iterator.return(); + } } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_buffer.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_buffer.ts index e2487edc5..1b3d68e8f 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_buffer.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_buffer.ts @@ -1,3 +1,4 @@ + import { ERR_BUFFER_OUT_OF_BOUNDS, ERR_OUT_OF_RANGE, @@ -5,18 +6,29 @@ import { ERR_INVALID_ARG_VALUE, ERR_INVALID_BUFFER_SIZE, ERR_UNKNOWN_ENCODING, -} from "./internal_errors"; +} from './internal_errors'; -import * as bufferUtil from "./buffer"; +import * as bufferUtil from './buffer'; -import { isAnyArrayBuffer, isArrayBufferView, isUint8Array } from "./internal_types"; +import { + isAnyArrayBuffer, + isArrayBufferView, + isUint8Array, +} from './internal_types'; -import { normalizeEncoding } from "./internal_utils"; +import { + normalizeEncoding, +} from './internal_utils'; -import { validateString } from "./validators"; +import { + validateString, +} from './validators'; -import * as internalUtil from "./util"; -import { InspectOptionsStylized, inspect as utilInspect } from "./internal_inspect"; +import * as internalUtil from './util'; +import { + InspectOptionsStylized, + inspect as utilInspect, +} from './internal_inspect'; // Temporary buffers to convert numbers. const float32Array = new Float32Array(1); @@ -35,7 +47,7 @@ export const bigEndian = uInt8Float32Array[3] === 0; export const kMaxLength = 2147483647; export const kStringMaxLength = 536870888; const MAX_UINT32 = 2 ** 32; -const kIsBuffer = Symbol("kIsBuffer"); +const kIsBuffer = Symbol('kIsBuffer'); const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" @@ -49,38 +61,34 @@ export const constants = { MAX_STRING_LENGTH: kStringMaxLength, }; -function createBuffer(length: number): Buffer { +function createBuffer(length: number) : Buffer { if (length > kMaxLength) { - throw new ERR_OUT_OF_RANGE("The given length is invalid", `0 to ${kMaxLength}`, length); + throw new ERR_OUT_OF_RANGE('The given length is invalid', `0 to ${kMaxLength}`, length); } const buf = new Uint8Array(length); Object.setPrototypeOf(buf, Buffer.prototype); return buf as Buffer; } -type WithImplicitCoercion = T | { valueOf(): T }; -type StringLike = WithImplicitCoercion | { [Symbol.toPrimitive](hint: "string"): string }; -type ArrayBufferLike = WithImplicitCoercion; -type BufferSource = StringLike | ArrayBufferLike | Uint8Array | ReadonlyArray; +type WithImplicitCoercion = | T | { valueOf(): T; }; +type StringLike = WithImplicitCoercion | { [Symbol.toPrimitive](hint: "string"): string; }; +type ArrayBufferLike = WithImplicitCoercion; +type BufferSource = StringLike|ArrayBufferLike|Uint8Array|ReadonlyArray; export interface Buffer extends Uint8Array { readonly buffer: ArrayBuffer; readonly parent: ArrayBuffer; readonly byteOffset: number; readonly length: number; - compare( - target: Uint8Array, - targetStart?: number, - targetEnd?: number, - sourceStart?: number, - sourceEnd?: number - ): number; - copy( - target: Uint8Array, - targetStart?: number, - sourceStart?: number, - sourceEnd?: number - ): number; + compare(target: Uint8Array, + targetStart?: number, + targetEnd?: number, + sourceStart?: number, + sourceEnd?: number): number; + copy(target: Uint8Array, + targetStart?: number, + sourceStart?: number, + sourceEnd?: number): number; equals(other: Uint8Array): boolean; fill(value: number, offset?: number, end?: number): this; fill(value: string, encoding?: string): this; @@ -98,32 +106,32 @@ export interface Buffer extends Uint8Array { lastIndexOf(value: string, encoding?: string): number; lastIndexOf(value: string, byteOffset?: number, encoding?: string): number; lastIndexOf(value: Uint8Array, byteOffset?: number): number; - readBigInt64BE(offset?: number): bigint; - readBigInt64LE(offset?: number): bigint; - readBigUInt64BE(offset?: number): bigint; - readBigUInt64LE(offset?: number): bigint; - readDoubleBE(offset?: number): number; - readDoubleLE(offset?: number): number; - readFloatBE(offset?: number): number; - readFloatLE(offset?: number): number; - readInt8(offset?: number): number; - readInt16BE(offset?: number): number; - readInt16LE(offset?: number): number; - readInt32BE(offset?: number): number; - readInt32LE(offset?: number): number; - readIntBE(offset?: number, byteLength?: number): number; - readIntLE(offset?: number, byteLength?: number): number; - readUInt8(offset?: number): number; - readUInt16BE(offset?: number): number; - readUInt16LE(offset?: number): number; - readUInt32BE(offset?: number): number; - readUInt32LE(offset?: number): number; - readUIntBE(offset?: number, byteLength?: number): number; - readUIntLE(offset?: number, byteLength?: number): number; + readBigInt64BE(offset?: number) : bigint; + readBigInt64LE(offset?: number) : bigint; + readBigUInt64BE(offset?: number) : bigint; + readBigUInt64LE(offset?: number) : bigint; + readDoubleBE(offset?: number) : number; + readDoubleLE(offset?: number) : number; + readFloatBE(offset?: number) : number; + readFloatLE(offset?: number) : number; + readInt8(offset?: number) : number; + readInt16BE(offset?: number) : number; + readInt16LE(offset?: number) : number; + readInt32BE(offset?: number) : number; + readInt32LE(offset?: number) : number; + readIntBE(offset?: number, byteLength?: number) : number; + readIntLE(offset?: number, byteLength?: number) : number; + readUInt8(offset?: number) : number; + readUInt16BE(offset?: number) : number; + readUInt16LE(offset?: number) : number; + readUInt32BE(offset?: number) : number; + readUInt32LE(offset?: number) : number; + readUIntBE(offset?: number, byteLength?: number) : number; + readUIntLE(offset?: number, byteLength?: number) : number; swap16(): this; swap32(): this; swap64(): this; - toJSON(): { type: "Buffer"; data: number[] }; + toJSON(): {type: 'Buffer', data: number[]}; toString(encoding?: string, start?: number, end?: number): string; write(string: string, encoding?: string): number; write(string: string, offset?: number, encoding?: string): number; @@ -150,29 +158,26 @@ export interface Buffer extends Uint8Array { writeUInt32LE(value: number, offset?: number): number; writeUIntBE(value: number, offset?: number, byteLength?: number): number; writeUIntLE(value: number, offset?: number, byteLength?: number): number; - new (array: Iterable): Buffer; + new (array:Iterable): Buffer; new (arrayBuffer: ArrayBufferLike, byteOffset?: number, length?: number): Buffer; new (buffer: ArrayBufferView): Buffer; new (size: number): Buffer; new (string: string, encoding?: string): Buffer; -} +}; -type FillValue = string | number | ArrayBufferView; +type FillValue = string|number|ArrayBufferView; -export function Buffer(value: number): Buffer; -export function Buffer(value: StringLike, encoding?: string): Buffer; -export function Buffer(value: ArrayBufferLike, byteOffset?: number, length?: number): Buffer; -export function Buffer( - value: Uint8Array | ReadonlyArray, - byteOffset?: number, - length?: number -): Buffer; -export function Buffer(value: StringLike, encoding?: string): Buffer; -export function Buffer( - value: number | BufferSource, - encodingOrOffset?: string | number, - length?: number -): Buffer { +export function Buffer(value: number) : Buffer; +export function Buffer(value: StringLike, encoding?: string) : Buffer; +export function Buffer(value: ArrayBufferLike, byteOffset?: number, length?: number) : Buffer; +export function Buffer(value: Uint8Array|ReadonlyArray, + byteOffset?: number, + length?: number) : Buffer; +export function Buffer(value: StringLike, + encoding?: string) : Buffer; +export function Buffer(value: number|BufferSource, + encodingOrOffset? : string|number, + length?: number) : Buffer { if (typeof value === "number") { if (typeof encodingOrOffset === "string") { throw new ERR_INVALID_ARG_TYPE("string", "string", value); @@ -197,7 +202,7 @@ Object.defineProperties(Buffer, { enumerable: true, value: 0, writable: false, - }, + } }); Object.defineProperties(Buffer.prototype, { @@ -226,26 +231,21 @@ Object.defineProperties(Buffer.prototype, { }, }); -function _from(value: BufferSource, encodingOrOffset?: string | number, length?: number): Buffer { +function _from(value: BufferSource, + encodingOrOffset? : string|number, + length?: number) : Buffer { if (typeof value === "string") { return fromString(value, encodingOrOffset as string | undefined) as Buffer; } if (typeof value === "object" && value != null) { if (isAnyArrayBuffer(value)) { - return fromArrayBuffer( - value as ArrayBufferLike, - encodingOrOffset as number, - length - ) as Buffer; + return fromArrayBuffer(value as ArrayBufferLike, encodingOrOffset as number, length) as Buffer; } const valueOf = value?.valueOf(); - if ( - valueOf != null && - valueOf !== value && - (typeof valueOf === "string" || typeof valueOf === "object") - ) { + if (valueOf != null && valueOf !== value && + (typeof valueOf === "string" || typeof valueOf === "object")) { return _from(valueOf as BufferSource, encodingOrOffset, length); } @@ -279,22 +279,23 @@ function _from(value: BufferSource, encodingOrOffset?: string | number, length?: "ArrayBuffer", "SharedArrayBuffer", "Array", - "Array-like Object", + "Array-like Object" ], - value + value, ); } -function from(value: StringLike, encoding?: string): Buffer; -function from(value: ArrayBufferLike, byteOffset?: number, length?: number): Buffer; -function from( - value: Uint8Array | ReadonlyArray, - byteOffset?: number, - length?: number -): Buffer; -function from(value: BufferSource, encodingOrOffset?: string | number, length?: number) { +function from(value: StringLike, + encoding?: string) : Buffer; +function from(value: ArrayBufferLike, + byteOffset?: number, + length?: number) : Buffer; +function from(value: Uint8Array|ReadonlyArray, + byteOffset?: number, + length?: number) : Buffer; +function from(value: BufferSource, encodingOrOffset?: string|number, length?: number) { return _from(value, encodingOrOffset, length); -} +}; function fromString(string: StringLike, encoding?: string) { if (typeof encoding !== "string" || encoding === "") { @@ -307,21 +308,20 @@ function fromString(string: StringLike, encoding?: string) { const ab = bufferUtil.decodeString(`${string}`, normalizedEncoding as string); if (ab === undefined) { - throw new ERR_INVALID_ARG_VALUE( - "string", - string, - `Unable to decode string using encoding ${encoding}` - ); + throw new ERR_INVALID_ARG_VALUE('string', string, + `Unable to decode string using encoding ${encoding}`); } return fromArrayBuffer(ab, 0, ab.byteLength); } -function fromArrayLike(array: Uint8Array | ReadonlyArray) { +function fromArrayLike(array: Uint8Array|ReadonlyArray) { const u8 = Uint8Array.from(array); return fromArrayBuffer(u8.buffer, u8.byteOffset, u8.byteLength); } -function fromArrayBuffer(obj: ArrayBufferLike, byteOffset: number, length?: number) { +function fromArrayBuffer(obj: ArrayBufferLike, + byteOffset: number, + length?: number) { // Convert byteOffset to integer if (byteOffset === undefined) { byteOffset = 0; @@ -361,16 +361,17 @@ Buffer.from = from; function of(...args: number[]) { const buf = Buffer.alloc(args.length); - for (let k = 0; k < args.length; k++) buf[k] = args[k]!; + for (let k = 0; k < args.length; k++) + buf[k] = args[k]!; return buf; } Buffer.of = of; -function alloc(size: number, fill?: FillValue, encoding?: string): Buffer { +function alloc(size: number, fill?: FillValue, encoding?: string) : Buffer { validateNumber(size, "size"); if (Number.isNaN(size)) { - throw new ERR_INVALID_ARG_VALUE.RangeError("size", size); + throw new ERR_INVALID_ARG_VALUE.RangeError('size', size); } if (size >= kMaxLength) { throw new ERR_OUT_OF_RANGE("size", `0 to ${kMaxLength}`, size); @@ -379,7 +380,7 @@ function alloc(size: number, fill?: FillValue, encoding?: string): Buffer { const buffer = createBuffer(size); if (fill !== undefined) { if (encoding !== undefined) { - validateString(encoding, "encoding"); + validateString(encoding, 'encoding'); } return buffer.fill(fill as any, encoding); } @@ -388,7 +389,7 @@ function alloc(size: number, fill?: FillValue, encoding?: string): Buffer { Buffer.alloc = alloc; -function allocUnsafe(size: number): Buffer { +function allocUnsafe(size: number) : Buffer { return alloc(size); } @@ -406,7 +407,7 @@ Buffer.isBuffer = function isBuffer(b: unknown) { return b != null && (b as any)[kIsBuffer] && b !== Buffer.prototype; }; -export function compare(a: Buffer | Uint8Array, b: Buffer | Uint8Array) { +export function compare(a: Buffer|Uint8Array, b: Buffer|Uint8Array) { if (isInstance(a, Uint8Array)) { const buf = a as Uint8Array; a = fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength); @@ -416,10 +417,10 @@ export function compare(a: Buffer | Uint8Array, b: Buffer | Uint8Array) { b = fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength); } if (!Buffer.isBuffer(a)) { - throw new ERR_INVALID_ARG_TYPE("a", ["Buffer", "Uint8Array"], typeof a); + throw new ERR_INVALID_ARG_TYPE('a', ['Buffer', 'Uint8Array'], typeof a); } if (!Buffer.isBuffer(b)) { - throw new ERR_INVALID_ARG_TYPE("b", ["Buffer", "Uint8Array"], typeof b); + throw new ERR_INVALID_ARG_TYPE('b', ['Buffer', 'Uint8Array'], typeof b); } if (a === b) return 0; @@ -429,16 +430,14 @@ export function compare(a: Buffer | Uint8Array, b: Buffer | Uint8Array) { Buffer.compare = compare; export function isEncoding(encoding: unknown) { - return ( - typeof encoding === "string" && + return typeof encoding === "string" && encoding.length !== 0 && - normalizeEncoding(encoding) !== undefined - ); + normalizeEncoding(encoding) !== undefined; } Buffer.isEncoding = isEncoding; -Buffer.concat = function concat(list: (Buffer | Uint8Array)[], length?: number) { +Buffer.concat = function concat(list: (Buffer|Uint8Array)[], length?: number) { if (!Array.isArray(list)) { throw new ERR_INVALID_ARG_TYPE("list", "(Buffer|Uint8Array)[]", list); } @@ -451,7 +450,7 @@ Buffer.concat = function concat(list: (Buffer | Uint8Array)[], length?: number) if (list[i]!.length !== undefined) { length += list[i]!.length; } else { - throw new ERR_INVALID_ARG_TYPE("list", "(Buffer|Uint8Array)[]", list[i]); + throw new ERR_INVALID_ARG_TYPE('list', '(Buffer|Uint8Array)[]', list[i]); } } } @@ -465,17 +464,15 @@ function base64ByteLength(str: string) { let len = str.length; if (str.charCodeAt(len - 1) === 0x3d) { len--; - } - if (len > 1 && str.charCodeAt(len - 1) === 0x3d) len--; + } if (len > 1 && str.charCodeAt(len - 1) === 0x3d) + len--; // Base64 ratio: 3/4 return (len * 3) >>> 2; } -function byteLength( - string: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - encoding?: string -) { +function byteLength(string: string|ArrayBufferView|ArrayBuffer|SharedArrayBuffer, + encoding?: string) { if (typeof string !== "string") { if (isArrayBufferView(string) || isAnyArrayBuffer(string)) { return string.byteLength; @@ -491,19 +488,19 @@ function byteLength( } switch (normalizedEncoding) { - case "ascii": + case 'ascii': // Fall through - case "latin1": + case 'latin1': return (string as string).length; - case "utf16le": + case 'utf16le': return (string as string).length * 2; - case "base64": + case 'base64': // Fall through - case "base64url": + case 'base64url': return base64ByteLength(string as string); - case "hex": + case 'hex': return (string as string).length >>> 1; - case "utf8": + case 'utf8': // Fall-through default: return bufferUtil.byteLength(string as string, normalizedEncoding as string); @@ -539,7 +536,10 @@ Buffer.prototype.swap64 = function swap64() { return this; }; -Buffer.prototype.toString = function toString(encoding?: string, start?: number, end?: number) { +Buffer.prototype.toString = function toString( + encoding?: string, + start?: number, + end?: number) { if (arguments.length === 0) { return bufferUtil.toString(this, 0, this.length, "utf8"); } @@ -574,31 +574,31 @@ Buffer.prototype.toString = function toString(encoding?: string, start?: number, Buffer.prototype.toLocaleString = Buffer.prototype.toString; -Buffer.prototype.equals = function equals(b: Buffer | Uint8Array) { +Buffer.prototype.equals = function equals(b: Buffer|Uint8Array) { return compare(this, b) === 0; }; Buffer.prototype.inspect = function inspect(_recurseTimes: number, ctx: InspectOptionsStylized) { let str = ""; const max = INSPECT_MAX_BYTES; - str = this.toString("hex", 0, max) - .replace(/(.{2})/g, "$1 ") - .trim(); + str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(); const remaining = this.length - max; if (remaining > 0) { - str += ` ... ${remaining} more byte${remaining > 1 ? "s" : ""}`; + str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`; } // Inspect special properties as well, if possible. if (ctx) { let extras = false; const filter = ctx.showHidden ? internalUtil.ALL_PROPERTIES : internalUtil.ONLY_ENUMERABLE; const obj: Record = { __proto__: null }; - internalUtil.getOwnNonIndexProperties(this, filter).forEach((key) => { - extras = true; - obj[key] = this[key]; - }); + internalUtil.getOwnNonIndexProperties(this, filter).forEach( + (key) => { + extras = true; + obj[key] = this[key]; + }); if (extras) { - if (this.length !== 0) str += ", "; + if (this.length !== 0) + str += ', '; // '[Object: null prototype] {'.length === 26 // This is guarded with a test. str += utilInspect(obj, { @@ -616,11 +616,11 @@ if (customInspectSymbol) { } Buffer.prototype.compare = function compare( - target: Buffer | Uint8Array, + target: Buffer|Uint8Array, start?: number, end?: number, thisStart?: number, - thisEnd?: number + thisEnd?: number, ) { if (isInstance(target, Uint8Array)) { target = fromArrayBuffer(target.buffer, target.byteOffset, target.byteLength); @@ -663,15 +663,15 @@ Buffer.prototype.compare = function compare( function includes( this: Buffer, - val: string | number | Buffer | Uint8Array, + val: string|number|Buffer|Uint8Array, byteOffset?: number, - encoding?: string -) { + encoding?: string) { return this.indexOf(val as any, byteOffset, encoding) !== -1; } Buffer.prototype.includes = includes; + // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, // OR the last index of `val` in `buffer` at offset <= `byteOffset`. // @@ -683,32 +683,32 @@ Buffer.prototype.includes = includes; // - dir - true for indexOf, false for lastIndexOf function bidirectionalIndexOf( buffer: Uint8Array, - val: string | number | Buffer | Uint8Array, - byteOffset: number | string | undefined, - encoding: string | undefined, - dir: boolean | undefined -) { + val: string|number|Buffer|Uint8Array, + byteOffset: number|string|undefined, + encoding: string|undefined, + dir: boolean|undefined) { + if (Buffer.isBuffer(val) && !isUint8Array(val)) { - throw new ERR_INVALID_ARG_TYPE("val", ["string", "number", "Buffer", "Uint8Array"], val); + throw new ERR_INVALID_ARG_TYPE('val', ['string', 'number', 'Buffer', 'Uint8Array'], val); } - if (typeof byteOffset === "string") { + if (typeof byteOffset === 'string') { encoding = byteOffset; byteOffset = undefined; - } else if ((byteOffset as number) > 0x7fffffff) { + } else if (byteOffset as number > 0x7fffffff) { byteOffset = 0x7fffffff; - } else if ((byteOffset as number) < -0x80000000) { + } else if (byteOffset as number < -0x80000000) { byteOffset = -0x80000000; } // Coerce to Number. Values like null and [] become 0. byteOffset = +(byteOffset as number); // If the offset is undefined, "foo", {}, coerces to NaN, search whole buffer. if (Number.isNaN(byteOffset)) { - byteOffset = dir ? 0 : buffer.length || buffer.byteLength; + byteOffset = dir ? 0 : (buffer.length || buffer.byteLength); } - dir = !!dir; // Cast to bool. + dir = !!dir; // Cast to bool. - if (typeof val === "number") { + if (typeof val === 'number') { val = (val >>> 0) & 0xff; if (dir) { return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset); @@ -717,8 +717,8 @@ function bidirectionalIndexOf( } } - if (typeof val !== "string" && !isUint8Array(val) && !Buffer.isBuffer(val)) { - throw new ERR_INVALID_ARG_TYPE("value", ["number", "string", "Buffer", "Uint8Array"], val); + if (typeof val !== 'string' && !isUint8Array(val) && !Buffer.isBuffer(val)) { + throw new ERR_INVALID_ARG_TYPE('value', ['number', 'string', 'Buffer', 'Uint8Array'], val); } let normalizedEncoding = normalizeEncoding(encoding); @@ -731,173 +731,160 @@ function bidirectionalIndexOf( } Buffer.prototype.indexOf = function indexOf( - val: string | number | Buffer | Uint8Array, - byteOffset?: number | string, - encoding?: string -) { + val: string|number|Buffer|Uint8Array, + byteOffset?: number|string, + encoding?: string) { return bidirectionalIndexOf(this, val, byteOffset, encoding, true); }; Buffer.prototype.lastIndexOf = function lastIndexOf( - val: string | number | Buffer | Uint8Array, - byteOffset?: number | string, - encoding?: string -) { + val: string|number|Buffer|Uint8Array, + byteOffset?: number|string, + encoding?: string) { return bidirectionalIndexOf(this, val, byteOffset, encoding, false); }; Buffer.prototype.asciiSlice = function asciiSlice(offset: number, length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "ascii"); + return bufferUtil.toString(this, offset, offset + length, 'ascii'); }; Buffer.prototype.base64Slice = function base64Slice(offset: number, length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "base64"); + return bufferUtil.toString(this, offset, offset + length, 'base64'); }; Buffer.prototype.base64urlSlice = function base64urlSlice(offset: number, length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "base64url"); + return bufferUtil.toString(this, offset, offset + length, 'base64url'); }; Buffer.prototype.hexSlice = function hexSlice(offset: number, length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "hex"); + return bufferUtil.toString(this, offset, offset + length, 'hex'); }; -Buffer.prototype.latin1Slice = function latin1Slice(offset: number, length: number) { +Buffer.prototype.latin1Slice = function latin1Slice(offset: number, + length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "latin1"); + return bufferUtil.toString(this, offset, offset + length, 'latin1'); }; Buffer.prototype.ucs2Slice = function ucs2Slice(offset: number, length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "utf16le"); + return bufferUtil.toString(this, offset, offset + length, 'utf16le'); }; Buffer.prototype.utf8Slice = function utf8Slice(offset: number, length: number) { validateOffset(offset, "offset", 0, this.length); validateOffset(length, "length", 0, this.length - offset); - return bufferUtil.toString(this, offset, offset + length, "utf8"); + return bufferUtil.toString(this, offset, offset + length, 'utf8'); }; -Buffer.prototype.asciiWrite = function asciiWrite( - string: StringLike, - offset?: number, - length?: number -) { +Buffer.prototype.asciiWrite = function asciiWrite(string: StringLike, + offset?: number, + length?: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "ascii"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'ascii'); }; -Buffer.prototype.base64Write = function base64Write( - string: StringLike, - offset?: number, - length?: number -) { +Buffer.prototype.base64Write = function base64Write(string: StringLike, + offset?: number, + length?: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "base64"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'base64'); }; -Buffer.prototype.base64urlWrite = function base64urlWrite( - string: StringLike, - offset?: number, - length?: number -) { +Buffer.prototype.base64urlWrite = function base64urlWrite(string: StringLike, + offset?: number, + length?: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "base64url"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'base64url'); }; -Buffer.prototype.hexWrite = function hexWrite(string: StringLike, offset: number, length: number) { +Buffer.prototype.hexWrite = function hexWrite(string: StringLike, + offset: number, + length: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "hex"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'hex'); }; -Buffer.prototype.latin1Write = function latin1Write( - string: StringLike, - offset: number, - length: number -) { +Buffer.prototype.latin1Write = function latin1Write(string: StringLike, + offset: number, + length: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "latin1"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'latin1'); }; -Buffer.prototype.ucs2Write = function ucs2Write( - string: StringLike, - offset: number, - length: number -) { +Buffer.prototype.ucs2Write = function ucs2Write(string: StringLike, + offset: number, + length: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "utf16le"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'utf16le'); }; -Buffer.prototype.utf8Write = function utf8Write( - string: StringLike, - offset: number, - length: number -) { +Buffer.prototype.utf8Write = function utf8Write(string: StringLike, + offset: number, + length: number) { offset ??= 0; length ??= this.length; validateOffset(offset as number, "offset", 0, this.length); validateOffset(length as number, "length", 0, this.length - offset); - return bufferUtil.write(this, `${string}`, offset as number, length as number, "utf8"); + return bufferUtil.write(this, `${string}`, offset as number, length as number, 'utf8'); }; -Buffer.prototype.write = function write( - string: StringLike, - offset?: number | string, - length?: number | string, - encoding?: string -) { +Buffer.prototype.write = function write(string: StringLike, + offset?: number | string, + length?: number | string, + encoding?: string) { string = `${string}`; if (offset === undefined) { // Buffer#write(string) return bufferUtil.write(this, string as string, 0, this.length, "utf8"); } - if (length === undefined && typeof offset === "string") { + if (length === undefined && typeof offset === 'string') { // Buffer#write(string, encoding) encoding = offset; length = this.length; offset = 0; } else { // Buffer#write(string, offset[, length][, encoding]) - validateOffset(offset as number, "offset", 0, this.length); + validateOffset(offset as number, 'offset', 0, this.length); const remaining = this.length - (offset as number); if (length === undefined) { length = remaining; - } else if (typeof length === "string") { + } else if (typeof length === 'string') { encoding = length; length = remaining; } else { - validateOffset(length, "length", 0, this.length); + validateOffset(length, 'length', 0, this.length); if (length > remaining) { length = remaining; } @@ -913,13 +900,8 @@ Buffer.prototype.write = function write( throw new ERR_UNKNOWN_ENCODING(encoding as string); } - return bufferUtil.write( - this, - string as string, - offset as number, - length as number, - normalizedEncoding as string - ); + return bufferUtil.write(this, string as string, offset as number, length as number, + normalizedEncoding as string); }; Buffer.prototype.toJSON = function toJSON() { @@ -961,24 +943,17 @@ Buffer.prototype.slice = function slice(start: number, end?: number) { Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE( offset: number, - byteLength: number -) { + byteLength: number) { if (offset === undefined) { throw new ERR_INVALID_ARG_TYPE("offset", "number", offset); } switch (byteLength) { - case 1: - return this.readUInt8(offset); - case 2: - return this.readUInt16LE(offset); - case 3: - return readUInt24LE(this, offset); - case 4: - return this.readUInt32LE(offset); - case 5: - return readUInt40LE(this, offset); - case 6: - return readUInt48LE(this, offset); + case 1: return this.readUInt8(offset); + case 2: return this.readUInt16LE(offset); + case 3: return readUInt24LE(this, offset); + case 4: return this.readUInt32LE(offset); + case 5: return readUInt40LE(this, offset); + case 6: return readUInt48LE(this, offset); default: boundsError(byteLength, 6, "byteLength"); } @@ -986,30 +961,24 @@ Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE( Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE( offset: number, - byteLength: number -) { + byteLength: number) { if (offset === undefined) { throw new ERR_INVALID_ARG_TYPE("offset", "number", offset); } switch (byteLength) { - case 1: - return this.readUInt8(offset); - case 2: - return this.readUInt16BE(offset); - case 3: - return readUInt24BE(this, offset); - case 4: - return this.readUInt32BE(offset); - case 5: - return readUInt40BE(this, offset); - case 6: - return readUInt48BE(this, offset); + case 1: return this.readUInt8(offset); + case 2: return this.readUInt16BE(offset); + case 3: return readUInt24BE(this, offset); + case 4: return this.readUInt32BE(offset); + case 5: return readUInt40BE(this, offset); + case 6: return readUInt48BE(this, offset); default: boundsError(byteLength, 6, "byteLength"); } }; -Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset: number = 0) { +Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8( + offset: number = 0) { validateOffset(offset, "offset", 0, this.length); const val = this[offset]; if (val === undefined) { @@ -1021,110 +990,104 @@ Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(off Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = readUInt16BE; -Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE( - offset: number = 0 -) { - validateOffset(offset, "offset", 0, this.length); - const first = this[offset]; - const last = this[offset + 1]; - if (first === undefined || last === undefined) { - boundsError(offset, this.length - 2); - } +Buffer.prototype.readUint16LE = + Buffer.prototype.readUInt16LE = + function readUInt16LE(offset: number = 0) { + validateOffset(offset, "offset", 0, this.length); + const first = this[offset]; + const last = this[offset + 1]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 2); + } - return first + last * 2 ** 8; -}; + return first + last * 2 ** 8; + }; + +Buffer.prototype.readUint32LE = + Buffer.prototype.readUInt32LE = + function readUInt32LE(this: Buffer, offset: number = 0) { + validateOffset(offset, "offset", 0, this.length); + const first = this[offset]; + const last = this[offset + 3]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 4); + } -Buffer.prototype.readUint32LE = Buffer.prototype.readUInt32LE = function readUInt32LE( - this: Buffer, - offset: number = 0 -) { - validateOffset(offset, "offset", 0, this.length); - const first = this[offset]; - const last = this[offset + 3]; - if (first === undefined || last === undefined) { - boundsError(offset, this.length - 4); - } - - return first + this[++offset]! * 2 ** 8 + this[++offset]! * 2 ** 16 + last * 2 ** 24; -}; + return first + + this[++offset]! * 2 ** 8 + + this[++offset]! * 2 ** 16 + + last * 2 ** 24; + }; Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = readUInt32BE; -Buffer.prototype.readBigUint64LE = Buffer.prototype.readBigUInt64LE = function readBigUInt64LE( - this: Buffer, - offset: number = 0 -) { - offset = offset >>> 0; - validateOffset(offset, "offset", 0, this.length); - const first = this[offset]; - const last = this[offset + 7]; - if (first === undefined || last === undefined) { - boundsError(offset, this.length - 8); - } - const lo = - first + this[++offset]! * 2 ** 8 + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 24; - const hi = - this[++offset]! + this[++offset]! * 2 ** 8 + this[++offset]! * 2 ** 16 + last * 2 ** 24; - return BigInt(lo) + (BigInt(hi) << BigInt(32)); -}; - -Buffer.prototype.readBigUint64BE = Buffer.prototype.readBigUInt64BE = function readBigUInt64BE( - this: Buffer, - offset: number = 0 +Buffer.prototype.readBigUint64LE = + Buffer.prototype.readBigUInt64LE = + function readBigUInt64LE(this: Buffer, offset: number = 0) { + offset = offset >>> 0; + validateOffset(offset, "offset", 0, this.length); + const first = this[offset]; + const last = this[offset + 7]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8); + } + const lo = first + this[++offset]! * 2 ** 8 + + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 24; + const hi = this[++offset]! + this[++offset]! * 2 ** 8 + + this[++offset]! * 2 ** 16 + last * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); + }; + +Buffer.prototype.readBigUint64BE = + Buffer.prototype.readBigUInt64BE = + function readBigUInt64BE(this: Buffer, offset: number = 0) { + offset = offset >>> 0; + validateOffset(offset, "offset", 0, this.length); + const first = this[offset]; + const last = this[offset + 7]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8); + } + const hi = first * 2 ** 24 + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 8 + this[++offset]!; + const lo = this[++offset]! * 2 ** 24 + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 8 + last; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); + }; + +Buffer.prototype.readIntLE = function readIntLE( + offset: number, + byteLength: number, ) { - offset = offset >>> 0; - validateOffset(offset, "offset", 0, this.length); - const first = this[offset]; - const last = this[offset + 7]; - if (first === undefined || last === undefined) { - boundsError(offset, this.length - 8); - } - const hi = - first * 2 ** 24 + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 8 + this[++offset]!; - const lo = - this[++offset]! * 2 ** 24 + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 8 + last; - return (BigInt(hi) << BigInt(32)) + BigInt(lo); -}; - -Buffer.prototype.readIntLE = function readIntLE(offset: number, byteLength: number) { if (offset === undefined) { throw new ERR_INVALID_ARG_TYPE("offset", "number", offset); } switch (byteLength) { - case 1: - return this.readInt8(offset); - case 2: - return this.readInt16LE(offset); - case 3: - return readInt24LE(this, offset); - case 4: - return this.readInt32LE(offset); - case 5: - return readInt40LE(this, offset); - case 6: - return readInt48LE(this, offset); + case 1: return this.readInt8(offset); + case 2: return this.readInt16LE(offset); + case 3: return readInt24LE(this, offset); + case 4: return this.readInt32LE(offset); + case 5: return readInt40LE(this, offset); + case 6: return readInt48LE(this, offset); default: boundsError(byteLength, 6, "byteLength"); } }; -Buffer.prototype.readIntBE = function readIntBE(offset: number, byteLength: number) { +Buffer.prototype.readIntBE = function readIntBE( + offset: number, + byteLength: number) { if (offset === undefined) { throw new ERR_INVALID_ARG_TYPE("offset", "number", offset); } switch (byteLength) { - case 1: - return this.readInt8(offset); - case 2: - return this.readInt16BE(offset); - case 3: - return readInt24BE(this, offset); - case 4: - return this.readInt32BE(offset); - case 5: - return readInt40BE(this, offset); - case 6: - return readInt48BE(this, offset); + case 1: return this.readInt8(offset); + case 2: return this.readInt16BE(offset); + case 3: return readInt24BE(this, offset); + case 4: return this.readInt32BE(offset); + case 5: return readInt40BE(this, offset); + case 6: return readInt48BE(this, offset); default: boundsError(byteLength, 6, "byteLength"); } @@ -1137,7 +1100,7 @@ Buffer.prototype.readInt8 = function readInt8(offset: number = 0) { boundsError(offset, this.length - 1); } - return val | ((val & (2 ** 7)) * 0x1fffffe); + return val | (val & 2 ** 7) * 0x1fffffe; }; Buffer.prototype.readInt16LE = function readInt16LE(offset: number = 0) { @@ -1149,7 +1112,7 @@ Buffer.prototype.readInt16LE = function readInt16LE(offset: number = 0) { } const val = first + last * 2 ** 8; - return val | ((val & (2 ** 15)) * 0x1fffe); + return val | (val & 2 ** 15) * 0x1fffe; }; Buffer.prototype.readInt16BE = function readInt16BE(offset: number = 0) { @@ -1161,7 +1124,7 @@ Buffer.prototype.readInt16BE = function readInt16BE(offset: number = 0) { } const val = first * 2 ** 8 + last; - return val | ((val & (2 ** 15)) * 0x1fffe); + return val | (val & 2 ** 15) * 0x1fffe; }; Buffer.prototype.readInt32LE = function readInt32LE(offset: number = 0) { @@ -1172,7 +1135,10 @@ Buffer.prototype.readInt32LE = function readInt32LE(offset: number = 0) { boundsError(offset, this.length - 4); } - return first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + (last << 24); // Overflow + return first + + this[++offset] * 2 ** 8 + + this[++offset] * 2 ** 16 + + (last << 24); // Overflow }; Buffer.prototype.readInt32BE = function readInt32BE(offset: number = 0) { @@ -1183,12 +1149,10 @@ Buffer.prototype.readInt32BE = function readInt32BE(offset: number = 0) { boundsError(offset, this.length - 4); } - return ( - (first << 24) + // Overflow + return (first << 24) + // Overflow this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + - last - ); + last; }; Buffer.prototype.readBigInt64LE = function readBigInt64LE(this: Buffer, offset: number = 0) { @@ -1199,14 +1163,13 @@ Buffer.prototype.readBigInt64LE = function readBigInt64LE(this: Buffer, offset: if (first === undefined || last === undefined) { boundsError(offset, this.length - 8); } - const val = - this[offset + 4]! + this[offset + 5]! * 2 ** 8 + this[offset + 6]! * 2 ** 16 + (last << 24); - return ( - (BigInt(val) << BigInt(32)) + + const val = this[offset + 4]! + this[offset + 5]! * 2 ** 8 + + this[offset + 6]! * 2 ** 16 + (last << 24); + return (BigInt(val) << BigInt(32)) + BigInt( - first + this[++offset]! * 2 ** 8 + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 24 - ) - ); + first + this[++offset]! * 2 ** 8 + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 24, + ); }; Buffer.prototype.readBigInt64BE = function readBigInt64BE(this: Buffer, offset: number = 0) { @@ -1217,114 +1180,106 @@ Buffer.prototype.readBigInt64BE = function readBigInt64BE(this: Buffer, offset: if (first === undefined || last === undefined) { boundsError(offset, this.length - 8); } - const val = - (first << 24) + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 8 + this[++offset]!; - return ( - (BigInt(val) << BigInt(32)) + + const val = (first << 24) + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 8 + this[++offset]!; + return (BigInt(val) << BigInt(32)) + BigInt( - this[++offset]! * 2 ** 24 + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 8 + last - ) - ); + this[++offset]! * 2 ** 24 + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 8 + last, + ); }; Buffer.prototype.readFloatLE = function readFloatLE(offset: number = 0) { - return bigEndian ? readFloatBackwards(this, offset) : readFloatForwards(this, offset); + return bigEndian + ? readFloatBackwards(this, offset) + : readFloatForwards(this, offset); }; Buffer.prototype.readFloatBE = function readFloatBE(offset: number = 0) { - return bigEndian ? readFloatForwards(this, offset) : readFloatBackwards(this, offset); + return bigEndian + ? readFloatForwards(this, offset) + : readFloatBackwards(this, offset); }; Buffer.prototype.readDoubleLE = function readDoubleLE(offset: number = 0) { - return bigEndian ? readDoubleBackwards(this, offset) : readDoubleForwards(this, offset); + return bigEndian + ? readDoubleBackwards(this, offset) + : readDoubleForwards(this, offset); }; Buffer.prototype.readDoubleBE = function readDoubleBE(offset: number = 0) { - return bigEndian ? readDoubleForwards(this, offset) : readDoubleBackwards(this, offset); -}; - -Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function writeUIntLE( - value: number, - offset: number, - byteLength: number -) { - switch (byteLength) { - case 1: - return writeU_Int8(this, value, offset, 0, 0xff); - case 2: - return writeU_Int16LE(this, value, offset, 0, 0xffff); - case 3: - return writeU_Int24LE(this, value, offset, 0, 0xffffff); - case 4: - return writeU_Int32LE(this, value, offset, 0, 0xffffffff); - case 5: - return writeU_Int40LE(this, value, offset, 0, 0xffffffffff); - case 6: - return writeU_Int48LE(this, value, offset, 0, 0xffffffffffff); - default: - boundsError(byteLength, 6, "byteLength"); - } -}; - -Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE( - value: number, - offset: number, - byteLength: number -) { - switch (byteLength) { - case 1: - return writeU_Int8(this, value, offset, 0, 0xff); - case 2: - return writeU_Int16BE(this, value, offset, 0, 0xffff); - case 3: - return writeU_Int24BE(this, value, offset, 0, 0xffffff); - case 4: - return writeU_Int32BE(this, value, offset, 0, 0xffffffff); - case 5: - return writeU_Int40BE(this, value, offset, 0, 0xffffffffff); - case 6: - return writeU_Int48BE(this, value, offset, 0, 0xffffffffffff); - default: - boundsError(byteLength, 6, "byteLength"); - } -}; + return bigEndian + ? readDoubleForwards(this, offset) + : readDoubleBackwards(this, offset); +}; + +Buffer.prototype.writeUintLE = + Buffer.prototype.writeUIntLE = + function writeUIntLE(value: number, offset: number, byteLength: number) { + switch (byteLength) { + case 1: return writeU_Int8(this, value, offset, 0, 0xff); + case 2: return writeU_Int16LE(this, value, offset, 0, 0xffff); + case 3: return writeU_Int24LE(this, value, offset, 0, 0xffffff); + case 4: return writeU_Int32LE(this, value, offset, 0, 0xffffffff); + case 5: return writeU_Int40LE(this, value, offset, 0, 0xffffffffff); + case 6: return writeU_Int48LE(this, value, offset, 0, 0xffffffffffff); + default: + boundsError(byteLength, 6, "byteLength"); + } + }; + +Buffer.prototype.writeUintBE = + Buffer.prototype.writeUIntBE = + function writeUIntBE(value: number, offset: number, byteLength: number) { + switch (byteLength) { + case 1: return writeU_Int8(this, value, offset, 0, 0xff); + case 2: return writeU_Int16BE(this, value, offset, 0, 0xffff); + case 3: return writeU_Int24BE(this, value, offset, 0, 0xffffff); + case 4: return writeU_Int32BE(this, value, offset, 0, 0xffffffff); + case 5: return writeU_Int40BE(this, value, offset, 0, 0xffffffffff); + case 6: return writeU_Int48BE(this, value, offset, 0, 0xffffffffffff); + default: + boundsError(byteLength, 6, "byteLength"); + } + }; Buffer.prototype.writeUint8 = Buffer.prototype.writeUInt8 = function writeUInt8( value: number, - offset: number = 0 + offset: number = 0, ) { return writeU_Int8(this, value, offset, 0, 0xff); }; -Buffer.prototype.writeUint16LE = Buffer.prototype.writeUInt16LE = function writeUInt16LE( - value: number, - offset: number = 0 -) { - return writeU_Int16LE(this, value, offset, 0, 0xffff); -}; +Buffer.prototype.writeUint16LE = + Buffer.prototype.writeUInt16LE = + function writeUInt16LE(value: number, offset: number = 0) { + return writeU_Int16LE(this, value, offset, 0, 0xffff); + }; -Buffer.prototype.writeUint16BE = Buffer.prototype.writeUInt16BE = function writeUInt16BE( - value: number, - offset: number = 0 -) { - return writeU_Int16BE(this, value, offset, 0, 0xffff); -}; +Buffer.prototype.writeUint16BE = + Buffer.prototype.writeUInt16BE = + function writeUInt16BE(value: number, offset: number = 0) { + return writeU_Int16BE(this, value, offset, 0, 0xffff); + }; -Buffer.prototype.writeUint32LE = Buffer.prototype.writeUInt32LE = function writeUInt32LE( - value: number, - offset: number = 0 -) { - return _writeUInt32LE(this, value, offset, 0, 0xffffffff); -}; +Buffer.prototype.writeUint32LE = + Buffer.prototype.writeUInt32LE = + function writeUInt32LE(value: number, offset: number = 0) { + return _writeUInt32LE(this, value, offset, 0, 0xffffffff); + }; -Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function writeUInt32BE( - value: number, - offset: number = 0 -) { - return _writeUInt32BE(this, value, offset, 0, 0xffffffff); -}; +Buffer.prototype.writeUint32BE = + Buffer.prototype.writeUInt32BE = + function writeUInt32BE(value: number, offset: number = 0) { + return _writeUInt32BE(this, value, offset, 0, 0xffffffff); + }; -function wrtBigUInt64LE(buf: Buffer, value: bigint, offset: number, min: bigint, max: bigint) { +function wrtBigUInt64LE( + buf: Buffer, + value: bigint, + offset: number, + min: bigint, + max: bigint) { checkIntBI(value, min, max, buf, offset, 7); let lo = Number(value & BigInt(4294967295)); buf[offset++] = lo; @@ -1334,7 +1289,7 @@ function wrtBigUInt64LE(buf: Buffer, value: bigint, offset: number, min: bigint, buf[offset++] = lo; lo = lo >> 8; buf[offset++] = lo; - let hi = Number((value >> BigInt(32)) & BigInt(4294967295)); + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); buf[offset++] = hi; hi = hi >> 8; buf[offset++] = hi; @@ -1345,7 +1300,12 @@ function wrtBigUInt64LE(buf: Buffer, value: bigint, offset: number, min: bigint, return offset; } -function wrtBigUInt64BE(buf: Buffer, value: bigint, offset: number, min: bigint, max: bigint) { +function wrtBigUInt64BE( + buf: Buffer, + value: bigint, + offset: number, + min: bigint, + max: bigint) { checkIntBI(value, min, max, buf, offset, 7); let lo = Number(value & BigInt(4294967295)); buf[offset + 7] = lo; @@ -1355,7 +1315,7 @@ function wrtBigUInt64BE(buf: Buffer, value: bigint, offset: number, min: bigint, buf[offset + 5] = lo; lo = lo >> 8; buf[offset + 4] = lo; - let hi = Number((value >> BigInt(32)) & BigInt(4294967295)); + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); buf[offset + 3] = hi; hi = hi >> 8; buf[offset + 2] = hi; @@ -1366,40 +1326,29 @@ function wrtBigUInt64BE(buf: Buffer, value: bigint, offset: number, min: bigint, return offset + 8; } -Buffer.prototype.writeBigUint64LE = Buffer.prototype.writeBigUInt64LE = function writeBigUInt64LE( - this: Buffer, - value: bigint, - offset: number = 0 -) { - return wrtBigUInt64LE(this, value, offset, 0n, 0xffffffffffffffffn); -}; +Buffer.prototype.writeBigUint64LE = + Buffer.prototype.writeBigUInt64LE = + function writeBigUInt64LE(this: Buffer, value: bigint, offset: number = 0) { + return wrtBigUInt64LE(this, value, offset, 0n, 0xffffffffffffffffn); + }; -Buffer.prototype.writeBigUint64BE = Buffer.prototype.writeBigUInt64BE = function writeBigUInt64BE( - this: Buffer, - value: bigint, - offset: number = 0 -) { - return wrtBigUInt64BE(this, value, offset, 0n, 0xffffffffffffffffn); -}; +Buffer.prototype.writeBigUint64BE = + Buffer.prototype.writeBigUInt64BE = + function writeBigUInt64BE(this: Buffer, value: bigint, offset: number = 0) { + return wrtBigUInt64BE(this, value, offset, 0n, 0xffffffffffffffffn); + }; Buffer.prototype.writeIntLE = function writeIntLE( value: number, offset: number, - byteLength: number -) { - switch (byteLength) { - case 1: - return writeU_Int8(this, value, offset, -0x80, 0x7f); - case 2: - return writeU_Int16LE(this, value, offset, -0x8000, 0x7fff); - case 3: - return writeU_Int24LE(this, value, offset, -0x800000, 0x7fffff); - case 4: - return writeU_Int32LE(this, value, offset, -0x80000000, 0x7fffffff); - case 5: - return writeU_Int40LE(this, value, offset, -0x8000000000, 0x7fffffffff); - case 6: - return writeU_Int48LE(this, value, offset, -0x800000000000, 0x7fffffffffff); + byteLength: number) { + switch(byteLength) { + case 1: return writeU_Int8(this, value, offset, -0x80, 0x7f); + case 2: return writeU_Int16LE(this, value, offset, -0x8000, 0x7fff); + case 3: return writeU_Int24LE(this, value, offset, -0x800000, 0x7fffff); + case 4: return writeU_Int32LE(this, value, offset, -0x80000000, 0x7fffffff); + case 5: return writeU_Int40LE(this, value, offset, -0x8000000000, 0x7fffffffff); + case 6: return writeU_Int48LE(this, value, offset, -0x800000000000, 0x7fffffffffff); default: boundsError(byteLength, 6, "byteLength"); } @@ -1408,21 +1357,14 @@ Buffer.prototype.writeIntLE = function writeIntLE( Buffer.prototype.writeIntBE = function writeIntBE( value: number, offset: number, - byteLength: number -) { - switch (byteLength) { - case 1: - return writeU_Int8(this, value, offset, -0x80, 0x7f); - case 2: - return writeU_Int16BE(this, value, offset, -0x8000, 0x7fff); - case 3: - return writeU_Int24BE(this, value, offset, -0x800000, 0x7fffff); - case 4: - return writeU_Int32BE(this, value, offset, -0x80000000, 0x7fffffff); - case 5: - return writeU_Int40BE(this, value, offset, -0x8000000000, 0x7fffffffff); - case 6: - return writeU_Int48BE(this, value, offset, -0x800000000000, 0x7fffffffffff); + byteLength: number) { + switch(byteLength) { + case 1: return writeU_Int8(this, value, offset, -0x80, 0x7f); + case 2: return writeU_Int16BE(this, value, offset, -0x8000, 0x7fff); + case 3: return writeU_Int24BE(this, value, offset, -0x800000, 0x7fffff); + case 4: return writeU_Int32BE(this, value, offset, -0x80000000, 0x7fffffff); + case 5: return writeU_Int40BE(this, value, offset, -0x8000000000, 0x7fffffffff); + case 6: return writeU_Int48BE(this, value, offset, -0x800000000000, 0x7fffffffffff); default: boundsError(byteLength, 6, "byteLength"); } @@ -1436,7 +1378,10 @@ Buffer.prototype.writeInt16LE = function writeInt16LE(value: number, offset: num return writeU_Int16LE(this, value, offset, -0x8000, 0x7fff); }; -Buffer.prototype.writeInt16BE = function writeInt16BE(value: number, offset: number = 0) { +Buffer.prototype.writeInt16BE = function writeInt16BE( + value: number, + offset: number = 0, +) { return writeU_Int16BE(this, value, offset, -0x8000, 0x7fff); }; @@ -1448,51 +1393,57 @@ Buffer.prototype.writeInt32BE = function writeInt32BE(value: number, offset: num return writeU_Int32BE(this, value, offset, -0x80000000, 0x7fffffff); }; -Buffer.prototype.writeBigInt64LE = function writeBigInt64LE( - this: Buffer, - value: bigint, - offset: number = 0 -) { - return wrtBigUInt64LE(this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn); -}; +Buffer.prototype.writeBigInt64LE = + function writeBigInt64LE(this: Buffer, value: bigint, offset: number = 0) { + return wrtBigUInt64LE(this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn); + }; -Buffer.prototype.writeBigInt64BE = function writeBigInt64BE( - this: Buffer, - value: bigint, - offset: number = 0 -) { - return wrtBigUInt64BE(this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn); -}; +Buffer.prototype.writeBigInt64BE = + function writeBigInt64BE(this: Buffer, value: bigint, offset: number = 0) { + return wrtBigUInt64BE(this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn); + }; -Buffer.prototype.writeFloatLE = function writeFloatLE(value: number, offset: number) { +Buffer.prototype.writeFloatLE = function writeFloatLE( + value: number, + offset: number, +) { return bigEndian ? writeFloatBackwards(this, value, offset) : writeFloatForwards(this, value, offset); }; -Buffer.prototype.writeFloatBE = function writeFloatBE(value: number, offset: number) { +Buffer.prototype.writeFloatBE = function writeFloatBE( + value: number, + offset: number, +) { return bigEndian ? writeFloatForwards(this, value, offset) : writeFloatBackwards(this, value, offset); }; -Buffer.prototype.writeDoubleLE = function writeDoubleLE(value: number, offset: number) { +Buffer.prototype.writeDoubleLE = function writeDoubleLE( + value: number, + offset: number, +) { return bigEndian ? writeDoubleBackwards(this, value, offset) : writeDoubleForwards(this, value, offset); }; -Buffer.prototype.writeDoubleBE = function writeDoubleBE(value: number, offset: number) { +Buffer.prototype.writeDoubleBE = function writeDoubleBE( + value: number, + offset: number, +) { return bigEndian ? writeDoubleForwards(this, value, offset) : writeDoubleBackwards(this, value, offset); }; Buffer.prototype.copy = function copy( - target: Buffer | Uint8Array, + target: Buffer|Uint8Array, targetStart?: number, sourceStart?: number, - sourceEnd?: number + sourceEnd?: number, ) { if (!isUint8Array(target)) { throw new ERR_INVALID_ARG_TYPE("target", ["Buffer", "Uint8Array"], target); @@ -1554,12 +1505,11 @@ Buffer.prototype.copy = function copy( }; Buffer.prototype.fill = function fill( - val: string | number | Buffer | Uint8Array, - start?: number | string, + val: string|number|Buffer|Uint8Array, + start?: number|string, end?: number, - encoding?: string -) { - let normalizedEncoding: string | undefined; + encoding?: string) { + let normalizedEncoding : string | undefined; if (typeof val === "string") { if (typeof start === "string") { encoding = start; @@ -1575,24 +1525,24 @@ Buffer.prototype.fill = function fill( } if (val.length === 1) { const code = val.charCodeAt(0); - if ((encoding === "utf8" && code < 128) || encoding === "latin1") { + if (encoding === "utf8" && code < 128 || encoding === "latin1") { val = code; } } } if (start !== undefined) { - validateNumber(start, "start"); + validateNumber(start, 'start'); } if (end !== undefined) { - validateNumber(end, "end"); + validateNumber(end, 'end'); } if ((end as number) < 0 || (end as number) > this.length) { - throw new ERR_OUT_OF_RANGE("end", `0 to ${this.length}`, end); + throw new ERR_OUT_OF_RANGE('end', `0 to ${this.length}`, end); } if ((start as number) < 0 || this.length < (start as number) || this.length < (end as number)) { - throw new ERR_OUT_OF_RANGE("start", "0 to end", start); + throw new ERR_OUT_OF_RANGE('start', '0 to end', start); } if ((end as number) <= (start as number)) { return this; @@ -1601,19 +1551,17 @@ Buffer.prototype.fill = function fill( end = end === void 0 ? this.length : end >>> 0; if (typeof val === "string") { - bufferUtil.fillImpl( - this, + bufferUtil.fillImpl(this, val as string, start as number, end as number, - normalizedEncoding - ); + normalizedEncoding); return this; } if (isArrayBufferView(val)) { if ((val as ArrayBufferView).byteLength === 0) { - throw new ERR_INVALID_ARG_VALUE("value", "zero-length"); + throw new ERR_INVALID_ARG_VALUE('value', 'zero-length'); } bufferUtil.fillImpl(this, val as ArrayBufferView, start as number, end as number); return this; @@ -1631,7 +1579,10 @@ Buffer.prototype.fill = function fill( return this; }; -function checkBounds(buf: Buffer, offset: number, byteLength2: number) { +function checkBounds( + buf: Buffer, + offset: number, + byteLength2: number) { validateOffset(offset, "offset", 0, buf.length); if (buf[offset] === undefined || buf[offset + byteLength2] === undefined) { boundsError(offset, buf.length - (byteLength2 + 1)); @@ -1639,13 +1590,12 @@ function checkBounds(buf: Buffer, offset: number, byteLength2: number) { } function checkIntBI( - value: bigint | number, - min: bigint | number, - max: bigint | number, + value: bigint|number, + min: bigint|number, + max: bigint|number, buf: Buffer, offset: number, - byteLength2: number -) { + byteLength2: number) { if (value > max || value < min) { const n = typeof min === "bigint" ? "n" : ""; let range; @@ -1666,16 +1616,13 @@ function checkIntBI( } export function isInstance(obj: unknown, type: Function) { - return ( - obj instanceof type || - (obj != null && - obj.constructor != null && - obj.constructor.name != null && - obj.constructor.name === type.name) - ); + return obj instanceof type || + obj != null && obj.constructor != null && + obj.constructor.name != null && obj.constructor.name === type.name; } -function readUInt48LE(buf: Buffer | Uint8Array, offset: number = 0) { + +function readUInt48LE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 5]; @@ -1683,16 +1630,14 @@ function readUInt48LE(buf: Buffer | Uint8Array, offset: number = 0) { boundsError(offset, buf.length - 6); } - return ( - first + + return first + buf[++offset]! * 2 ** 8 + buf[++offset]! * 2 ** 16 + buf[++offset]! * 2 ** 24 + - (buf[++offset]! + last * 2 ** 8) * 2 ** 32 - ); + (buf[++offset]! + last * 2 ** 8) * 2 ** 32; } -function readUInt40LE(buf: Buffer | Uint8Array, offset: number = 0) { +function readUInt40LE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 4]; @@ -1700,16 +1645,14 @@ function readUInt40LE(buf: Buffer | Uint8Array, offset: number = 0) { boundsError(offset, buf.length - 5); } - return ( - first + + return first + buf[++offset]! * 2 ** 8 + buf[++offset]! * 2 ** 16 + buf[++offset]! * 2 ** 24 + - last * 2 ** 32 - ); + last * 2 ** 32; } -function readUInt24LE(buf: Buffer | Uint8Array, offset: number = 0) { +function readUInt24LE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 2]; @@ -1720,7 +1663,7 @@ function readUInt24LE(buf: Buffer | Uint8Array, offset: number = 0) { return first + buf[++offset]! * 2 ** 8 + last * 2 ** 16; } -function readUInt48BE(buf: Buffer | Uint8Array, offset: number = 0) { +function readUInt48BE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 5]; @@ -1728,16 +1671,14 @@ function readUInt48BE(buf: Buffer | Uint8Array, offset: number = 0) { boundsError(offset, buf.length - 6); } - return ( - (first * 2 ** 8 + buf[++offset]!) * 2 ** 32 + + return (first * 2 ** 8 + buf[++offset]!) * 2 ** 32 + buf[++offset]! * 2 ** 24 + buf[++offset]! * 2 ** 16 + buf[++offset]! * 2 ** 8 + - last - ); + last; } -function readUInt40BE(buf: Buffer | Uint8Array, offset: number = 0) { +function readUInt40BE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 4]; @@ -1745,16 +1686,14 @@ function readUInt40BE(buf: Buffer | Uint8Array, offset: number = 0) { boundsError(offset, buf.length - 5); } - return ( - first * 2 ** 32 + + return first * 2 ** 32 + buf[++offset]! * 2 ** 24 + buf[++offset]! * 2 ** 16 + buf[++offset]! * 2 ** 8 + - last - ); + last; } -function readUInt24BE(buf: Buffer | Uint8Array, offset: number = 0) { +function readUInt24BE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 2]; @@ -1784,10 +1723,13 @@ function readUInt32BE(this: Buffer, offset: number = 0) { boundsError(offset, this.length - 4); } - return first * 2 ** 24 + this[++offset]! * 2 ** 16 + this[++offset]! * 2 ** 8 + last; + return first * 2 ** 24 + + this[++offset]! * 2 ** 16 + + this[++offset]! * 2 ** 8 + + last; } -function readDoubleBackwards(buffer: Buffer | Uint8Array, offset: number = 0) { +function readDoubleBackwards(buffer: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buffer.length); const first = buffer[offset]; const last = buffer[offset + 7]; @@ -1806,7 +1748,7 @@ function readDoubleBackwards(buffer: Buffer | Uint8Array, offset: number = 0) { return float64Array[0]; } -function readDoubleForwards(buffer: Buffer | Uint8Array, offset: number = 0) { +function readDoubleForwards(buffer: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buffer.length); const first = buffer[offset]; const last = buffer[offset + 7]; @@ -1825,7 +1767,7 @@ function readDoubleForwards(buffer: Buffer | Uint8Array, offset: number = 0) { return float64Array[0]; } -function writeDoubleForwards(buffer: Buffer | Uint8Array, val: number, offset: number = 0) { +function writeDoubleForwards(buffer: Buffer|Uint8Array, val: number, offset: number = 0) { val = +val; checkBounds(buffer as any, offset, 7); @@ -1841,7 +1783,7 @@ function writeDoubleForwards(buffer: Buffer | Uint8Array, val: number, offset: n return offset; } -function writeDoubleBackwards(buffer: Buffer | Uint8Array, val: number, offset: number = 0) { +function writeDoubleBackwards(buffer: Buffer|Uint8Array, val: number, offset: number = 0) { val = +val; checkBounds(buffer as any, offset, 7); @@ -1857,7 +1799,7 @@ function writeDoubleBackwards(buffer: Buffer | Uint8Array, val: number, offset: return offset; } -function readFloatBackwards(buffer: Buffer | Uint8Array, offset: number = 0) { +function readFloatBackwards(buffer: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buffer.length); const first = buffer[offset]; const last = buffer[offset + 3]; @@ -1872,7 +1814,7 @@ function readFloatBackwards(buffer: Buffer | Uint8Array, offset: number = 0) { return float32Array[0]; } -function readFloatForwards(buffer: Buffer | Uint8Array, offset: number = 0) { +function readFloatForwards(buffer: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buffer.length); const first = buffer[offset]; const last = buffer[offset + 3]; @@ -1887,7 +1829,7 @@ function readFloatForwards(buffer: Buffer | Uint8Array, offset: number = 0) { return float32Array[0]; } -function writeFloatForwards(buffer: Buffer | Uint8Array, val: number, offset: number = 0) { +function writeFloatForwards(buffer: Buffer|Uint8Array, val: number, offset: number = 0) { val = +val; checkBounds(buffer as any, offset, 3); @@ -1899,7 +1841,7 @@ function writeFloatForwards(buffer: Buffer | Uint8Array, val: number, offset: nu return offset; } -function writeFloatBackwards(buffer: Buffer | Uint8Array, val: number, offset: number = 0) { +function writeFloatBackwards(buffer: Buffer|Uint8Array, val: number, offset: number = 0) { val = +val; checkBounds(buffer as any, offset, 3); @@ -1911,7 +1853,7 @@ function writeFloatBackwards(buffer: Buffer | Uint8Array, val: number, offset: n return offset; } -function readInt24LE(buf: Buffer | Uint8Array, offset: number = 0) { +function readInt24LE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 2]; @@ -1920,10 +1862,10 @@ function readInt24LE(buf: Buffer | Uint8Array, offset: number = 0) { } const val = first + buf[++offset]! * 2 ** 8 + last * 2 ** 16; - return val | ((val & (2 ** 23)) * 0x1fe); + return val | (val & 2 ** 23) * 0x1fe; } -function readInt40LE(buf: Buffer | Uint8Array, offset: number = 0) { +function readInt40LE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 4]; @@ -1931,16 +1873,14 @@ function readInt40LE(buf: Buffer | Uint8Array, offset: number = 0) { boundsError(offset, buf.length - 5); } - return ( - (last | ((last & (2 ** 7)) * 0x1fffffe)) * 2 ** 32 + + return (last | (last & 2 ** 7) * 0x1fffffe) * 2 ** 32 + first + buf[++offset]! * 2 ** 8 + buf[++offset]! * 2 ** 16 + - buf[++offset]! * 2 ** 24 - ); + buf[++offset]! * 2 ** 24; } -function readInt48LE(buf: Buffer | Uint8Array, offset: number = 0) { +function readInt48LE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 5]; @@ -1949,16 +1889,14 @@ function readInt48LE(buf: Buffer | Uint8Array, offset: number = 0) { } const val = buf[offset + 4]! + last * 2 ** 8; - return ( - (val | ((val & (2 ** 15)) * 0x1fffe)) * 2 ** 32 + + return (val | (val & 2 ** 15) * 0x1fffe) * 2 ** 32 + first + buf[++offset]! * 2 ** 8 + buf[++offset]! * 2 ** 16 + - buf[++offset]! * 2 ** 24 - ); + buf[++offset]! * 2 ** 24; } -function readInt24BE(buf: Buffer | Uint8Array, offset: number = 0) { +function readInt24BE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 2]; @@ -1967,10 +1905,10 @@ function readInt24BE(buf: Buffer | Uint8Array, offset: number = 0) { } const val = first * 2 ** 16 + buf[++offset]! * 2 ** 8 + last; - return val | ((val & (2 ** 23)) * 0x1fe); + return val | (val & 2 ** 23) * 0x1fe; } -function readInt48BE(buf: Buffer | Uint8Array, offset: number = 0) { +function readInt48BE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 5]; @@ -1979,16 +1917,14 @@ function readInt48BE(buf: Buffer | Uint8Array, offset: number = 0) { } const val = buf[++offset]! + first * 2 ** 8; - return ( - (val | ((val & (2 ** 15)) * 0x1fffe)) * 2 ** 32 + + return (val | (val & 2 ** 15) * 0x1fffe) * 2 ** 32 + buf[++offset]! * 2 ** 24 + buf[++offset]! * 2 ** 16 + buf[++offset]! * 2 ** 8 + - last - ); + last; } -function readInt40BE(buf: Buffer | Uint8Array, offset: number = 0) { +function readInt40BE(buf: Buffer|Uint8Array, offset: number = 0) { validateOffset(offset, "offset", 0, buf.length); const first = buf[offset]; const last = buf[offset + 4]; @@ -1996,16 +1932,14 @@ function readInt40BE(buf: Buffer | Uint8Array, offset: number = 0) { boundsError(offset, buf.length - 5); } - return ( - (first | ((first & (2 ** 7)) * 0x1fffffe)) * 2 ** 32 + + return (first | (first & 2 ** 7) * 0x1fffffe) * 2 ** 32 + buf[++offset]! * 2 ** 24 + buf[++offset]! * 2 ** 16 + buf[++offset]! * 2 ** 8 + - last - ); + last; } -function boundsError(value: number, length: number, type?: string): never { +function boundsError(value: number, length: number, type?: string) : never { if (Math.floor(value) !== value) { throw new ERR_OUT_OF_RANGE(type || "offset", "an integer", value); } @@ -2014,7 +1948,11 @@ function boundsError(value: number, length: number, type?: string): never { throw new ERR_BUFFER_OUT_OF_BOUNDS(); } - throw new ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value); + throw new ERR_OUT_OF_RANGE( + type || "offset", + `>= ${type ? 1 : 0} and <= ${length}`, + value, + ); } function validateNumber(value: unknown, name: string) { @@ -2024,13 +1962,12 @@ function validateNumber(value: unknown, name: string) { } function checkInt( - value: number | bigint, - min: number | bigint, - max: number | bigint, + value: number|bigint, + min: number|bigint, + max: number|bigint, buf: Buffer, offset: number, - byteLength: number -) { + byteLength: number) { if (value > max || value < min) { const n = typeof min === "bigint" ? "n" : ""; let range; @@ -2038,8 +1975,7 @@ function checkInt( if (min === 0 || min === 0n) { range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`; } else { - range = - `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and ` + + range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and ` + `< 2${n} ** ${(byteLength + 1) * 8 - 1}${n}`; } } else { @@ -2050,16 +1986,25 @@ function checkInt( checkBounds(buf, offset, byteLength); } -function toInteger(n: number | undefined, defaultVal: number) { +function toInteger(n: number|undefined, defaultVal: number) { if (n === undefined) n = 0; n = +(n as number); - if (!Number.isNaN(n) && n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER) { - return n % 1 === 0 ? n : Math.floor(n); + if ( + !Number.isNaN(n) && + n >= Number.MIN_SAFE_INTEGER && + n <= Number.MAX_SAFE_INTEGER + ) { + return ((n % 1) === 0 ? n : Math.floor(n)); } return defaultVal; } -function writeU_Int8(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int8( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); if (value > max || value < min) { @@ -2073,7 +2018,12 @@ function writeU_Int8(buf: Buffer, value: number, offset: number, min: number, ma return offset + 1; } -function writeU_Int16BE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int16BE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 1); @@ -2083,7 +2033,12 @@ function writeU_Int16BE(buf: Buffer, value: number, offset: number, min: number, return offset; } -function _writeUInt32LE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function _writeUInt32LE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 3); @@ -2098,7 +2053,12 @@ function _writeUInt32LE(buf: Buffer, value: number, offset: number, min: number, return offset; } -function writeU_Int16LE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int16LE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 1); @@ -2108,7 +2068,12 @@ function writeU_Int16LE(buf: Buffer, value: number, offset: number, min: number, return offset; } -function _writeUInt32BE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function _writeUInt32BE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 3); @@ -2123,7 +2088,12 @@ function _writeUInt32BE(buf: Buffer, value: number, offset: number, min: number, return offset + 4; } -function writeU_Int48BE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int48BE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 5); @@ -2141,7 +2111,12 @@ function writeU_Int48BE(buf: Buffer, value: number, offset: number, min: number, return offset + 4; } -function writeU_Int40BE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int40BE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 4); @@ -2157,7 +2132,12 @@ function writeU_Int40BE(buf: Buffer, value: number, offset: number, min: number, return offset + 4; } -function writeU_Int32BE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int32BE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 3); @@ -2172,7 +2152,12 @@ function writeU_Int32BE(buf: Buffer, value: number, offset: number, min: number, return offset + 4; } -function writeU_Int24BE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int24BE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 2); @@ -2189,7 +2174,7 @@ function validateOffset( value: number, name: string, min: number = 0, - max: number = Number.MAX_SAFE_INTEGER + max: number = Number.MAX_SAFE_INTEGER, ) { if (typeof value !== "number") { throw new ERR_INVALID_ARG_TYPE(name, "number", value); @@ -2202,7 +2187,12 @@ function validateOffset( } } -function writeU_Int48LE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int48LE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 5); @@ -2220,7 +2210,12 @@ function writeU_Int48LE(buf: Buffer, value: number, offset: number, min: number, return offset; } -function writeU_Int40LE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int40LE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 4); @@ -2237,7 +2232,12 @@ function writeU_Int40LE(buf: Buffer, value: number, offset: number, min: number, return offset; } -function writeU_Int32LE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int32LE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 3); @@ -2252,7 +2252,12 @@ function writeU_Int32LE(buf: Buffer, value: number, offset: number, min: number, return offset; } -function writeU_Int24LE(buf: Buffer, value: number, offset: number, min: number, max: number) { +function writeU_Int24LE( + buf: Buffer, + value: number, + offset: number, + min: number, + max: number) { value = +value; validateOffset(offset, "offset", 0, buf.length); checkInt(value, min, max, buf, offset, 2); diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_errors.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_errors.ts index ab8e66830..5a6b40f0c 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_errors.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_errors.ts @@ -57,7 +57,10 @@ export class NodeTypeError extends NodeErrorAbstraction implements TypeError { } } -function createInvalidArgType(name: string, expected: string | string[]): string { +function createInvalidArgType( + name: string, + expected: string | string[], +): string { // https://github.com/nodejs/node/blob/f3eb224/lib/internal/errors.js#L1037-L1087 expected = Array.isArray(expected) ? expected : [expected]; let msg = "The "; @@ -196,10 +199,7 @@ export class ERR_CRYPTO_INCOMPATIBLE_KEY extends NodeError { export class ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE extends NodeError { constructor(actual: string, expected: string) { - super( - "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", - `Invalid key object type ${actual}, expected ${expected}.` - ); + super("ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", `Invalid key object type ${actual}, expected ${expected}.`); } } @@ -226,7 +226,10 @@ export class ERR_INVALID_ARG_VALUE_RANGE extends NodeRangeError { const type = name.includes(".") ? "property" : "argument"; const inspected = inspect(value); - super("ERR_INVALID_ARG_VALUE", `The ${type} '${name}' ${reason}. Received ${inspected}`); + super( + "ERR_INVALID_ARG_VALUE", + `The ${type} '${name}' ${reason}. Received ${inspected}`, + ); } } @@ -235,7 +238,10 @@ export class ERR_INVALID_ARG_VALUE extends NodeTypeError { const type = name.includes(".") ? "property" : "argument"; const inspected = inspect(value); - super("ERR_INVALID_ARG_VALUE", `The ${type} '${name}' ${reason}. Received ${inspected}`); + super( + "ERR_INVALID_ARG_VALUE", + `The ${type} '${name}' ${reason}. Received ${inspected}`, + ); } static RangeError = ERR_INVALID_ARG_VALUE_RANGE; @@ -244,10 +250,16 @@ export class ERR_INVALID_ARG_VALUE extends NodeTypeError { export class ERR_OUT_OF_RANGE extends RangeError { code = "ERR_OUT_OF_RANGE"; - constructor(str: string, range: string, input: unknown, replaceDefaultBoolean = false) { + constructor( + str: string, + range: string, + input: unknown, + replaceDefaultBoolean = false) { // TODO(later): Implement internal assert? // assert(range, 'Missing "range" argument'); - let msg = replaceDefaultBoolean ? str : `The value of "${str}" is out of range.`; + let msg = replaceDefaultBoolean + ? str + : `The value of "${str}" is out of range.`; let received; if (Number.isInteger(input) && Math.abs(input as number) > 2 ** 32) { received = addNumericalSeparator(String(input)); @@ -292,14 +304,17 @@ export class ERR_BUFFER_OUT_OF_BOUNDS extends NodeRangeError { "ERR_BUFFER_OUT_OF_BOUNDS", name ? `"${name}" is outside of buffer bounds` - : "Attempt to access memory outside buffer bounds" + : "Attempt to access memory outside buffer bounds", ); } } export class ERR_INVALID_BUFFER_SIZE extends NodeRangeError { constructor(size: number) { - super("ERR_INVALID_BUFFER_SIZE", `Buffer size must be a multiple of ${size}-bits`); + super( + "ERR_INVALID_BUFFER_SIZE", + `Buffer size must be a multiple of ${size}-bits`, + ); } } @@ -357,9 +372,11 @@ export class ERR_INVALID_RETURN_VALUE extends NodeTypeError { constructor(input: string, name: string, value: unknown) { super( "ERR_INVALID_RETURN_VALUE", - `Expected ${input} to be returned from the "${name}" function but got ${determineSpecificType( - value - )}.` + `Expected ${input} to be returned from the "${name}" function but got ${ + determineSpecificType( + value, + ) + }.`, ); } } @@ -378,7 +395,9 @@ export class ERR_MISSING_ARGS extends NodeTypeError { const wrap = (a: unknown) => `"${a}"`; - args = args.map((a) => (Array.isArray(a) ? a.map(wrap).join(" or ") : wrap(a))); + args = args.map((a) => + Array.isArray(a) ? a.map(wrap).join(" or ") : wrap(a) + ); switch (len) { case 1: @@ -406,8 +425,8 @@ export class ERR_FALSY_VALUE_REJECTION extends NodeError { } export class ERR_METHOD_NOT_IMPLEMENTED extends NodeError { - constructor(name: string | symbol) { - if (typeof name === "symbol") { + constructor(name: string|symbol) { + if (typeof name === 'symbol') { name = (name as symbol).description!; } super("ERR_METHOD_NOT_IMPLEMENTED", `The ${name} method is not implemented`); @@ -420,16 +439,16 @@ export class ERR_STREAM_CANNOT_PIPE extends NodeError { } } export class ERR_STREAM_DESTROYED extends NodeError { - constructor(name: string | symbol) { - if (typeof name === "symbol") { + constructor(name: string|symbol) { + if (typeof name === 'symbol') { name = (name as symbol).description!; } super("ERR_STREAM_DESTROYED", `Cannot call ${name} after a stream was destroyed`); } } export class ERR_STREAM_ALREADY_FINISHED extends NodeError { - constructor(name: string | symbol) { - if (typeof name === "symbol") { + constructor(name: string|symbol) { + if (typeof name === 'symbol') { name = (name as symbol).description!; } super("ERR_STREAM_ALREADY_FINISHED", `Cannot call ${name} after a stream was finished`); @@ -469,5 +488,5 @@ export function aggregateTwoErrors(innerError: any, outerError: any) { (err as any).code = outerError.code; return err; } - return innerError || outerError; + return innerError || outerError } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_inspect.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_inspect.ts index 4e5c8c797..99ac8ecbd 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_inspect.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_inspect.ts @@ -1,3 +1,4 @@ + import * as internal from "./util"; import { Buffer } from "./internal_buffer"; @@ -34,9 +35,9 @@ import { validateObject, validateString } from "./validators"; function assert(value: boolean, message = "Assertion failed"): asserts value { if (!value) throw new Error(message); } -assert.fail = function (message = "Assertion failed"): never { +assert.fail = function(message = "Assertion failed"): never { throw new Error(message); -}; +} function isError(e: unknown): e is Error { // An error could be an instance of Error while not being a native error @@ -46,28 +47,18 @@ function isError(e: unknown): e is Error { } const typedArrayPrototype = Object.getPrototypeOf(Uint8Array).prototype; -const typedArrayPrototypeLength: (this: internal.TypedArray) => number = - Object.getOwnPropertyDescriptor(typedArrayPrototype, "length")!.get!; -const typedArrayPrototypeToStringTag: (this: internal.TypedArray) => string = - Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag)!.get!; - -const setPrototypeSize: (this: Set) => number = Object.getOwnPropertyDescriptor( - Set.prototype, - "size" -)!.get!; -const mapPrototypeSize: (this: Map) => number = Object.getOwnPropertyDescriptor( - Map.prototype, - "size" -)!.get!; +const typedArrayPrototypeLength: (this: internal.TypedArray) => number = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length")!.get!; +const typedArrayPrototypeToStringTag: (this: internal.TypedArray) => string = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag)!.get!; + +const setPrototypeSize: (this: Set) => number = Object.getOwnPropertyDescriptor(Set.prototype, "size")!.get!; +const mapPrototypeSize: (this: Map) => number = Object.getOwnPropertyDescriptor(Map.prototype, "size")!.get!; let maxStack_ErrorName: string; let maxStack_ErrorMessage: string; function isStackOverflowError(err: Error): boolean { if (maxStack_ErrorMessage === undefined) { try { - function overflowStack() { - overflowStack(); - } + function overflowStack() { overflowStack(); } overflowStack(); } catch (err) { assert(isError(err)); @@ -76,15 +67,16 @@ function isStackOverflowError(err: Error): boolean { } } - return err && err.name === maxStack_ErrorName && err.message === maxStack_ErrorMessage; + return err && err.name === maxStack_ErrorName && + err.message === maxStack_ErrorMessage; } -export const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom"); +export const customInspectSymbol = Symbol.for('nodejs.util.inspect.custom'); const colorRegExp = /\u001b\[\d\d?m/g; function removeColors(str: string): string { - return str.replace(colorRegExp, ""); + return str.replace(colorRegExp, ''); } export interface InspectOptions { @@ -188,11 +180,12 @@ export interface InspectOptionsStylized extends InspectOptions { } const builtInObjects = new Set( - Object.getOwnPropertyNames(globalThis).filter((e) => /^[A-Z][a-zA-Z0-9]+$/.exec(e) !== null) + Object.getOwnPropertyNames(globalThis).filter( + (e) => /^[A-Z][a-zA-Z0-9]+$/.exec(e) !== null) ); // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot -const isUndetectableObject = (v: unknown): boolean => typeof v === "undefined" && v !== undefined; +const isUndetectableObject = (v: unknown): boolean => typeof v === 'undefined' && v !== undefined; // These options must stay in sync with `getUserOptions`. So if any option will // be added or removed, `getUserOptions` must also be updated accordingly. @@ -215,14 +208,10 @@ const kObjectType = 0; const kArrayType = 1; const kArrayExtrasType = 2; -const strEscapeSequencesRegExp = - /[\x00-\x1f\x27\x5c\x7f-\x9f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<~]))"; -const ansi = new RegExp(ansiPattern, "g"); +const ansiPattern = '[\\u001B\\u009B][[\\]()#;?]*' + + '(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*' + + '|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' + + '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'; +const ansi = new RegExp(ansiPattern, 'g'); interface Context extends Required { maxArrayLength: number; @@ -452,11 +294,9 @@ function getUserOptions(ctx: Context, isCrossContext: boolean): InspectOptionsSt // and remove all other non-primitives, including non-primitive user options. if (isCrossContext) { Object.setPrototypeOf(ret, null); - for (const key of Object.keys(ret) as (keyof InspectOptionsStylized)[]) { - if ( - (typeof ret[key] === "object" || typeof ret[key] === "function") && - ret[key] !== null - ) { + for (const key of (Object.keys(ret) as (keyof InspectOptionsStylized)[])) { + if ((typeof ret[key] === 'object' || typeof ret[key] === 'function') && + ret[key] !== null) { delete ret[key]; } } @@ -468,7 +308,7 @@ function getUserOptions(ctx: Context, isCrossContext: boolean): InspectOptionsSt // Continue regardless of error. } - if (typeof stylized !== "string") return value; + if (typeof stylized !== 'string') return value; // `stylized` is a string as it should be, which is safe to pass along. return stylized; }, null); @@ -484,12 +324,7 @@ function getUserOptions(ctx: Context, isCrossContext: boolean): InspectOptionsSt * @param {object} opts Optional options object that alters the output. */ /* Legacy: value, showHidden, depth, colors */ -export function inspect( - value: unknown, - showHidden?: boolean, - depth?: number | null, - color?: boolean -): string; +export function inspect(value: unknown, showHidden?: boolean, depth?: number | null, color?: boolean): string; export function inspect(value: unknown, opts?: InspectOptions): string; export function inspect(value: unknown, opts?: Partial | boolean): string { // Default options @@ -523,7 +358,7 @@ export function inspect(value: unknown, opts?: Partial | } } // Set user-specified options - if (typeof opts === "boolean") { + if (typeof opts === 'boolean') { ctx.showHidden = opts; } else if (opts) { const optKeys = Object.keys(opts) as (keyof InspectOptionsStylized)[]; @@ -534,8 +369,7 @@ export function inspect(value: unknown, opts?: Partial | // functionality. if ( Object.prototype.hasOwnProperty.call(inspectDefaultOptions, key) || - key === "stylize" - ) { + key === 'stylize') { (ctx as Record)[key] = opts[key]; } else if (ctx.userOptions === undefined) { // This is required to pass through the actual user input. @@ -551,12 +385,12 @@ export function inspect(value: unknown, opts?: Partial | } inspect.custom = customInspectSymbol; -Object.defineProperty(inspect, "defaultOptions", { +Object.defineProperty(inspect, 'defaultOptions', { get() { return inspectDefaultOptions; }, set(options) { - validateObject(options, "options"); + validateObject(options, 'options'); return Object.assign(inspectDefaultOptions, options); }, }); @@ -628,36 +462,36 @@ function defineColorAlias(target: string, alias: string) { }); } -defineColorAlias("gray", "grey"); -defineColorAlias("gray", "blackBright"); -defineColorAlias("bgGray", "bgGrey"); -defineColorAlias("bgGray", "bgBlackBright"); -defineColorAlias("dim", "faint"); -defineColorAlias("strikethrough", "crossedout"); -defineColorAlias("strikethrough", "strikeThrough"); -defineColorAlias("strikethrough", "crossedOut"); -defineColorAlias("hidden", "conceal"); -defineColorAlias("inverse", "swapColors"); -defineColorAlias("inverse", "swapcolors"); -defineColorAlias("doubleunderline", "doubleUnderline"); +defineColorAlias('gray', 'grey'); +defineColorAlias('gray', 'blackBright'); +defineColorAlias('bgGray', 'bgGrey'); +defineColorAlias('bgGray', 'bgBlackBright'); +defineColorAlias('dim', 'faint'); +defineColorAlias('strikethrough', 'crossedout'); +defineColorAlias('strikethrough', 'strikeThrough'); +defineColorAlias('strikethrough', 'crossedOut'); +defineColorAlias('hidden', 'conceal'); +defineColorAlias('inverse', 'swapColors'); +defineColorAlias('inverse', 'swapcolors'); +defineColorAlias('doubleunderline', 'doubleUnderline'); // TODO(BridgeAR): Add function style support for more complex styles. // Don't use 'blue' not visible on cmd.exe inspect.styles = { __proto__: null, - special: "cyan", - number: "yellow", - bigint: "yellow", - boolean: "yellow", - undefined: "grey", - null: "bold", - string: "green", - symbol: "green", - date: "magenta", + special: 'cyan', + number: 'yellow', + bigint: 'yellow', + boolean: 'yellow', + undefined: 'grey', + null: 'bold', + string: 'green', + symbol: 'green', + date: 'magenta', name: undefined, // TODO(BridgeAR): Highlight regular expressions properly. - regexp: "red", - module: "underline", + regexp: 'red', + module: 'underline', }; function addQuotes(str: string, quotes: number): string { @@ -689,9 +523,10 @@ function strEscape(str: string): string { if (str.includes("'")) { // This invalidates the charCode and therefore can not be matched for // anymore. - if (!str.includes('"')) { + if (!(str.includes('"'))) { singleQuote = -1; - } else if (!str.includes("`") && !str.includes("${")) { + } else if (!str.includes('`') && + !str.includes('${')) { singleQuote = -2; } if (singleQuote !== 39) { @@ -701,17 +536,21 @@ function strEscape(str: string): string { } // Some magic numbers that worked out fine while benchmarking with v8 6.0 - if (str.length < 5000 && escapeTest.exec(str) === null) return addQuotes(str, singleQuote); + if (str.length < 5000 && escapeTest.exec(str) === null) + return addQuotes(str, singleQuote); if (str.length > 100) { str = str.replace(escapeReplace, escapeFn); return addQuotes(str, singleQuote); } - let result = ""; + let result = ''; let last = 0; for (let i = 0; i < str.length; i++) { const point = str.charCodeAt(i); - if (point === singleQuote || point === 92 || point < 32 || (point > 126 && point < 160)) { + if (point === singleQuote || + point === 92 || + point < 32 || + (point > 126 && point < 160)) { if (last === i) { result += meta[point]; } else { @@ -741,7 +580,8 @@ function stylizeWithColor(str: string, styleType: Style): string { const style = inspect.styles[styleType]; if (style !== undefined) { const color = (inspect.colors as unknown as Record)[style]; - if (color !== undefined) return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`; + if (color !== undefined) + return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`; } return str; } @@ -763,27 +603,20 @@ function isInstanceof(object: unknown, proto: Function): boolean { } } -function getConstructorName( - obj: object, - ctx: Context, - recurseTimes: number, - protoProps?: string[] -): string | null { +function getConstructorName(obj: object, ctx: Context, recurseTimes: number, protoProps?: string[]): string | null { let firstProto: unknown; const tmp = obj; while (obj || isUndetectableObject(obj)) { - const descriptor = Object.getOwnPropertyDescriptor(obj, "constructor"); - if ( - descriptor !== undefined && - typeof descriptor.value === "function" && - descriptor.value.name !== "" && - isInstanceof(tmp, descriptor.value) - ) { - if ( - protoProps !== undefined && - (firstProto !== obj || !builtInObjects.has(descriptor.value.name)) - ) { - addPrototypeProperties(ctx, tmp, firstProto || tmp, recurseTimes, protoProps); + const descriptor = Object.getOwnPropertyDescriptor(obj, 'constructor'); + if (descriptor !== undefined && + typeof descriptor.value === 'function' && + descriptor.value.name !== '' && + isInstanceof(tmp, descriptor.value)) { + if (protoProps !== undefined && + (firstProto !== obj || + !builtInObjects.has(descriptor.value.name))) { + addPrototypeProperties( + ctx, tmp, firstProto || tmp, recurseTimes, protoProps); } return String(descriptor.value.name); } @@ -804,7 +637,8 @@ function getConstructorName( return `${res} `; } - const protoConstr = getConstructorName(firstProto!, ctx, recurseTimes + 1, protoProps); + const protoConstr = getConstructorName( + firstProto!, ctx, recurseTimes + 1, protoProps); if (protoConstr === null) { return `${res} <${inspect(firstProto, { @@ -820,13 +654,7 @@ function getConstructorName( // This function has the side effect of adding prototype properties to the // `output` argument (which is an array). This is intended to highlight user // defined prototype properties. -function addPrototypeProperties( - ctx: Context, - main: object, - obj: Object, - recurseTimes: number, - output: string[] -): void { +function addPrototypeProperties(ctx: Context, main: object, obj: Object, recurseTimes: number, output: string[]): void { let depth = 0; let keys: PropertyKey[] | undefined; let keySet: Set | undefined; @@ -838,12 +666,10 @@ function addPrototypeProperties( return; } // Stop as soon as a built-in object type is detected. - const descriptor = Object.getOwnPropertyDescriptor(obj, "constructor"); - if ( - descriptor !== undefined && - typeof descriptor.value === "function" && - builtInObjects.has(descriptor.value.name) - ) { + const descriptor = Object.getOwnPropertyDescriptor(obj, 'constructor'); + if (descriptor !== undefined && + typeof descriptor.value === 'function' && + builtInObjects.has(descriptor.value.name)) { return; } } @@ -858,18 +684,17 @@ function addPrototypeProperties( ctx.seen.push(main); for (const key of keys) { // Ignore the `constructor` property and keys that exist on layers above. - if ( - key === "constructor" || + if (key === 'constructor' || Object.prototype.hasOwnProperty.call(main, key) || - (depth !== 0 && keySet!.has(key)) - ) { + (depth !== 0 && keySet!.has(key))) { continue; } const desc = Object.getOwnPropertyDescriptor(obj, key); - if (typeof desc?.value === "function") { + if (typeof desc?.value === 'function') { continue; } - const value = formatProperty(ctx, obj, recurseTimes, key, kObjectType, desc, main); + const value = formatProperty( + ctx, obj, recurseTimes, key, kObjectType, desc, main); if (ctx.colors) { // Faint! output.push(`\u001b[2m${value}\u001b[22m`); @@ -884,15 +709,15 @@ function addPrototypeProperties( } while (++depth !== 3); } -function getPrefix(constructor: string | null, tag: string, fallback: string, size = ""): string { +function getPrefix(constructor: string | null, tag: string, fallback: string, size = ''): string { if (constructor === null) { - if (tag !== "" && fallback !== tag) { + if (tag !== '' && fallback !== tag) { return `[${fallback}${size}: null prototype] [${tag}] `; } return `[${fallback}${size}: null prototype] `; } - if (tag !== "" && constructor !== tag) { + if (tag !== '' && constructor !== tag) { return `${constructor}${size} [${tag}] `; } return `${constructor}${size} `; @@ -904,7 +729,8 @@ function getKeys(value: object, showHidden: boolean): PropertyKey[] { const symbols = Object.getOwnPropertySymbols(value); if (showHidden) { keys = Object.getOwnPropertyNames(value); - if (symbols.length !== 0) keys.push(...symbols); + if (symbols.length !== 0) + keys.push(...symbols); } else { // This might throw if `value` is a Module Namespace Object from an // unevaluated module, but we don't want to perform the actual type @@ -914,16 +740,12 @@ function getKeys(value: object, showHidden: boolean): PropertyKey[] { try { keys = Object.keys(value); } catch (err: any) { - assert( - isNativeError(err) && - err.name === "ReferenceError" && - isModuleNamespaceObject(value) - ); + assert(isNativeError(err) && err.name === 'ReferenceError' && + isModuleNamespaceObject(value)); keys = Object.getOwnPropertyNames(value); } if (symbols.length !== 0) { - const filter = (key: PropertyKey) => - Object.prototype.propertyIsEnumerable.call(value, key); + const filter = (key: PropertyKey) => Object.prototype.propertyIsEnumerable.call(value, key); keys.push(...symbols.filter(filter)); } } @@ -931,11 +753,11 @@ function getKeys(value: object, showHidden: boolean): PropertyKey[] { } function getCtxStyle(value: unknown, constructor: string | null, tag: string): string { - let fallback = ""; + let fallback = ''; if (constructor === null) { fallback = internal.getConstructorName(value); if (fallback === tag) { - fallback = "Object"; + fallback = 'Object'; } } return getPrefix(constructor, tag, fallback); @@ -943,7 +765,7 @@ function getCtxStyle(value: unknown, constructor: string | null, tag: string): s function formatProxy(ctx: Context, proxy: internal.ProxyDetails, recurseTimes: number): string { if (ctx.depth !== null && recurseTimes > ctx.depth) { - return ctx.stylize("Proxy [Array]", "special"); + return ctx.stylize('Proxy [Array]', 'special'); } recurseTimes += 1; ctx.indentationLvl += 2; @@ -952,24 +774,22 @@ function formatProxy(ctx: Context, proxy: internal.ProxyDetails, recurseTimes: n formatValue(ctx, proxy.handler, recurseTimes), ]; ctx.indentationLvl -= 2; - return reduceToSingleString(ctx, res, "", ["Proxy [", "]"], kArrayExtrasType, recurseTimes); + return reduceToSingleString( + ctx, res, '', ['Proxy [', ']'], kArrayExtrasType, recurseTimes); } // Note: using `formatValue` directly requires the indentation level to be // corrected by setting `ctx.indentationLvL += diff` and then to decrease the // value afterwards again. -function formatValue( - ctx: Context, - value: unknown, - recurseTimes: number, - typedArray?: unknown -): string { +function formatValue(ctx: Context, value: unknown, recurseTimes: number, typedArray?: unknown): string { // Primitive types cannot have properties. - if (typeof value !== "object" && typeof value !== "function" && !isUndetectableObject(value)) { + if (typeof value !== 'object' && + typeof value !== 'function' && + !isUndetectableObject(value)) { return formatPrimitive(ctx.stylize, value as Primitive, ctx); } if (value === null) { - return ctx.stylize("null", "null"); + return ctx.stylize('null', 'null'); } // Memorize the context for custom inspection on proxies. @@ -979,7 +799,7 @@ function formatValue( const proxy = internal.getProxyDetails(value); if (proxy !== undefined) { if (proxy === null || proxy.target === null) { - return ctx.stylize("", "special"); + return ctx.stylize('', 'special'); } if (ctx.showProxy) { return formatProxy(ctx, proxy, recurseTimes); @@ -993,9 +813,7 @@ function formatValue( let maybeCustom = (value as Record)[customInspectSymbol]; // WORKERD SPECIFIC PATCH: if `value` is a JSG resource type, use a well-known custom inspect - const maybeResourceTypeInspect = (value as Record)[ - internal.kResourceTypeInspect - ]; + const maybeResourceTypeInspect = (value as Record)[internal.kResourceTypeInspect]; if (typeof maybeResourceTypeInspect === "object") { maybeCustom = formatJsgResourceType.bind( context as Record, @@ -1003,31 +821,30 @@ function formatValue( ); } - if ( - typeof maybeCustom === "function" && + if (typeof maybeCustom === 'function' && // Filter out the util module, its inspect function is special. maybeCustom !== inspect && // Also filter out any prototype objects using the circular check. - !((value as object).constructor && (value as object).constructor.prototype === value) - ) { + !((value as object).constructor && (value as object).constructor.prototype === value)) { // This makes sure the recurseTimes are reported as before while using // a counter internally. const depth = ctx.depth === null ? null : ctx.depth - recurseTimes; - const isCrossContext = proxy !== undefined || !(context instanceof Object); + const isCrossContext = + proxy !== undefined || !(context instanceof Object); const ret = Function.prototype.call.call( maybeCustom, context, depth, getUserOptions(ctx, isCrossContext), - inspect + inspect, ); // If the custom inspection method returned `this`, don't go into // infinite recursion. if (ret !== context) { - if (typeof ret !== "string") { + if (typeof ret !== 'string') { return formatValue(ctx, ret, recurseTimes); } - return ret.replaceAll("\n", `\n${" ".repeat(ctx.indentationLvl)}`); + return ret.replaceAll('\n', `\n${' '.repeat(ctx.indentationLvl)}`); } } } @@ -1046,18 +863,13 @@ function formatValue( ctx.circular.set(value, index); } } - return ctx.stylize(`[Circular *${index}]`, "special"); + return ctx.stylize(`[Circular *${index}]`, 'special'); } return formatRaw(ctx, value, recurseTimes, typedArray); } -function formatRaw( - ctx: Context, - value: unknown, - recurseTimes: number, - typedArray: unknown -): string { +function formatRaw(ctx: Context, value: unknown, recurseTimes: number, typedArray: unknown): string { let keys: PropertyKey[] | undefined; let protoProps: string[] | undefined; if (ctx.showHidden && (ctx.depth === null || recurseTimes <= ctx.depth)) { @@ -1073,19 +885,16 @@ function formatRaw( let tag = (value as { [Symbol.toStringTag]?: string })[Symbol.toStringTag]; // Only list the tag in case it's non-enumerable / not an own property. // Otherwise we'd print this twice. - if ( - typeof tag !== "string" || - (tag !== "" && - (ctx.showHidden - ? Object.prototype.hasOwnProperty - : Object.prototype.propertyIsEnumerable - ).call(value, Symbol.toStringTag)) - ) { - tag = ""; - } - let base = ""; - let formatter: (ctx: Context, value: any, recurseTimes: number) => string[] = - getEmptyFormatArray; + if (typeof tag !== 'string' || + (tag !== '' && + (ctx.showHidden ? + Object.prototype.hasOwnProperty : + Object.prototype.propertyIsEnumerable) + .call(value, Symbol.toStringTag))) { + tag = ''; + } + let base = ''; + let formatter: (ctx: Context, value: any, recurseTimes: number) => string[] = getEmptyFormatArray; let braces: [string, string] | undefined; let noIterator = true; let i = 0; @@ -1103,7 +912,7 @@ function formatRaw( if (isEntriesObject) { // WORKERD SPECIFIC PATCH: if `value` is an object with entries, format them like a map const size = value[kEntries].length; - const prefix = getPrefix(constructor, tag, "Object", `(${size})`); + const prefix = getPrefix(constructor, tag, 'Object', `(${size})`); keys = getKeys(value, ctx.showHidden); // Remove `kEntries` and `size` from keys @@ -1112,70 +921,66 @@ function formatRaw( if (sizeIndex !== -1) keys.splice(sizeIndex, 1); formatter = formatMap.bind(null, value[kEntries][Symbol.iterator]()); - if (size === 0 && keys.length === 0 && protoProps === undefined) return `${prefix}{}`; - braces = [`${prefix}{`, "}"]; + if (size === 0 && keys.length === 0 && protoProps === undefined) + return `${prefix}{}`; + braces = [`${prefix}{`, '}']; } else if (Array.isArray(value)) { // Only set the constructor for non ordinary ("Array [...]") arrays. - const prefix = - constructor !== "Array" || tag !== "" - ? getPrefix(constructor, tag, "Array", `(${value.length})`) - : ""; + const prefix = (constructor !== 'Array' || tag !== '') ? + getPrefix(constructor, tag, 'Array', `(${value.length})`) : + ''; keys = internal.getOwnNonIndexProperties(value, filter); - braces = [`${prefix}[`, "]"]; + braces = [`${prefix}[`, ']']; if (value.length === 0 && keys.length === 0 && protoProps === undefined) return `${braces[0]}]`; extrasType = kArrayExtrasType; formatter = formatArray; } else if (isSet(value)) { const size = setPrototypeSize.call(value); - const prefix = getPrefix(constructor, tag, "Set", `(${size})`); + const prefix = getPrefix(constructor, tag, 'Set', `(${size})`); keys = getKeys(value, ctx.showHidden); - formatter = - constructor !== null - ? formatSet.bind(null, value) - : formatSet.bind(null, Set.prototype.values.call(value)); - if (size === 0 && keys.length === 0 && protoProps === undefined) return `${prefix}{}`; - braces = [`${prefix}{`, "}"]; + formatter = constructor !== null ? + formatSet.bind(null, value) : + formatSet.bind(null, Set.prototype.values.call(value)); + if (size === 0 && keys.length === 0 && protoProps === undefined) + return `${prefix}{}`; + braces = [`${prefix}{`, '}']; } else if (isMap(value)) { const size = mapPrototypeSize.call(value); - const prefix = getPrefix(constructor, tag, "Map", `(${size})`); + const prefix = getPrefix(constructor, tag, 'Map', `(${size})`); keys = getKeys(value, ctx.showHidden); - formatter = - constructor !== null - ? formatMap.bind(null, value) - : formatMap.bind(null, Map.prototype.entries.call(value)); - if (size === 0 && keys.length === 0 && protoProps === undefined) return `${prefix}{}`; - braces = [`${prefix}{`, "}"]; + formatter = constructor !== null ? + formatMap.bind(null, value) : + formatMap.bind(null, Map.prototype.entries.call(value)); + if (size === 0 && keys.length === 0 && protoProps === undefined) + return `${prefix}{}`; + braces = [`${prefix}{`, '}']; } else if (isTypedArray(value)) { keys = internal.getOwnNonIndexProperties(value, filter); let bound = value; - let fallback = ""; + let fallback = ''; if (constructor === null) { fallback = typedArrayPrototypeToStringTag.call(value); // Reconstruct the array information. - bound = new ( - globalThis as unknown as Record< - string, - { new (value: NodeJS.TypedArray): NodeJS.TypedArray } - > - )[fallback]!(value); + bound = new (globalThis as unknown as Record)[fallback]!(value); } const size = typedArrayPrototypeLength.call(value); const prefix = getPrefix(constructor, tag, fallback, `(${size})`); - braces = [`${prefix}[`, "]"]; - if (value.length === 0 && keys.length === 0 && !ctx.showHidden) return `${braces[0]}]`; + braces = [`${prefix}[`, ']']; + if (value.length === 0 && keys.length === 0 && !ctx.showHidden) + return `${braces[0]}]`; // Special handle the value. The original value is required below. The // bound function is required to reconstruct missing information. formatter = formatTypedArray.bind(null, bound, size); extrasType = kArrayExtrasType; } else if (isMapIterator(value)) { keys = getKeys(value, ctx.showHidden); - braces = getIteratorBraces("Map", tag); + braces = getIteratorBraces('Map', tag); // Add braces to the formatter parameters. formatter = formatIterator.bind(null, braces); } else if (isSetIterator(value)) { keys = getKeys(value, ctx.showHidden); - braces = getIteratorBraces("Set", tag); + braces = getIteratorBraces('Set', tag); // Add braces to the formatter parameters. formatter = formatIterator.bind(null, braces); } else { @@ -1184,73 +989,77 @@ function formatRaw( } if (noIterator) { keys = getKeys(value as object, ctx.showHidden); - braces = ["{", "}"]; - if (constructor === "Object") { + braces = ['{', '}']; + if (constructor === 'Object') { if (isArgumentsObject(value)) { - braces[0] = "[Arguments] {"; - } else if (tag !== "") { - braces[0] = `${getPrefix(constructor, tag, "Object")}{`; + braces[0] = '[Arguments] {'; + } else if (tag !== '') { + braces[0] = `${getPrefix(constructor, tag, 'Object')}{`; } if (keys.length === 0 && protoProps === undefined) { return `${braces[0]}}`; } - } else if (typeof value === "function") { + } else if (typeof value === 'function') { base = getFunctionBase(value, constructor, tag); - if (keys.length === 0 && protoProps === undefined) return ctx.stylize(base, "special"); + if (keys.length === 0 && protoProps === undefined) + return ctx.stylize(base, 'special'); } else if (isRegExp(value)) { // Make RegExps say that they are RegExps - base = RegExp.prototype.toString.call(constructor !== null ? value : new RegExp(value)); - const prefix = getPrefix(constructor, tag, "RegExp"); - if (prefix !== "RegExp ") base = `${prefix}${base}`; - if ( - (keys.length === 0 && protoProps === undefined) || - (ctx.depth !== null && recurseTimes > ctx.depth) - ) { - return ctx.stylize(base, "regexp"); + base = RegExp.prototype.toString.call( + constructor !== null ? value : new RegExp(value) + ); + const prefix = getPrefix(constructor, tag, 'RegExp'); + if (prefix !== 'RegExp ') + base = `${prefix}${base}`; + if ((keys.length === 0 && protoProps === undefined) || + (ctx.depth !== null && recurseTimes > ctx.depth)) { + return ctx.stylize(base, 'regexp'); } } else if (isDate(value)) { // Make dates with properties first say the date - base = Number.isNaN(Date.prototype.getTime.call(value)) - ? Date.prototype.toString.call(value) - : Date.prototype.toISOString.call(value); - const prefix = getPrefix(constructor, tag, "Date"); - if (prefix !== "Date ") base = `${prefix}${base}`; + base = Number.isNaN(Date.prototype.getTime.call(value)) ? + Date.prototype.toString.call(value) : + Date.prototype.toISOString.call(value); + const prefix = getPrefix(constructor, tag, 'Date'); + if (prefix !== 'Date ') + base = `${prefix}${base}`; if (keys.length === 0 && protoProps === undefined) { - return ctx.stylize(base, "date"); + return ctx.stylize(base, 'date'); } } else if (isError(value)) { base = formatError(value, constructor, tag, ctx, keys); - if (keys.length === 0 && protoProps === undefined) return base; + if (keys.length === 0 && protoProps === undefined) + return base; } else if (isAnyArrayBuffer(value)) { // Fast path for ArrayBuffer and SharedArrayBuffer. // Can't do the same for DataView because it has a non-primitive // .buffer property that we need to recurse for. - const arrayType = isArrayBuffer(value) ? "ArrayBuffer" : "SharedArrayBuffer"; + const arrayType = isArrayBuffer(value) ? 'ArrayBuffer' : + 'SharedArrayBuffer'; const prefix = getPrefix(constructor, tag, arrayType); if (typedArray === undefined) { formatter = formatArrayBuffer; } else if (keys.length === 0 && protoProps === undefined) { - return ( - prefix + `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength, false)} }` - ); + return prefix + + `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength, false)} }`; } braces[0] = `${prefix}{`; - keys.unshift("byteLength"); + keys.unshift('byteLength'); } else if (isDataView(value)) { - braces[0] = `${getPrefix(constructor, tag, "DataView")}{`; + braces[0] = `${getPrefix(constructor, tag, 'DataView')}{`; // .buffer goes last, it's not a primitive like the others. - keys.unshift("byteLength", "byteOffset", "buffer"); + keys.unshift('byteLength', 'byteOffset', 'buffer'); } else if (isPromise(value)) { - braces[0] = `${getPrefix(constructor, tag, "Promise")}{`; + braces[0] = `${getPrefix(constructor, tag, 'Promise')}{`; formatter = formatPromise; } else if (isWeakSet(value)) { - braces[0] = `${getPrefix(constructor, tag, "WeakSet")}{`; + braces[0] = `${getPrefix(constructor, tag, 'WeakSet')}{`; formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection; } else if (isWeakMap(value)) { - braces[0] = `${getPrefix(constructor, tag, "WeakMap")}{`; + braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`; formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection; } else if (isModuleNamespaceObject(value)) { - braces[0] = `${getPrefix(constructor, tag, "Module")}{`; + braces[0] = `${getPrefix(constructor, tag, 'Module')}{`; // Special handle keys for namespace objects. formatter = formatNamespaceObject.bind(null, keys); } else if (isBoxedPrimitive(value)) { @@ -1268,8 +1077,9 @@ function formatRaw( if (ctx.depth !== null && recurseTimes > ctx.depth) { let constructorName = getCtxStyle(value, constructor, tag).slice(0, -1); - if (constructor !== null) constructorName = `[${constructorName}]`; - return ctx.stylize(constructorName, "special"); + if (constructor !== null) + constructorName = `[${constructorName}]`; + return ctx.stylize(constructorName, 'special'); } recurseTimes += 1; @@ -1280,7 +1090,9 @@ function formatRaw( try { output = formatter(ctx, value, recurseTimes); for (i = 0; i < keys!.length; i++) { - output.push(formatProperty(ctx, value as object, recurseTimes, keys![i]!, extrasType)); + output.push( + formatProperty(ctx, value as object, recurseTimes, keys![i]!, extrasType), + ); } if (protoProps !== undefined) { output.push(...protoProps); @@ -1292,10 +1104,10 @@ function formatRaw( if (ctx.circular !== undefined) { const index = ctx.circular.get(value); if (index !== undefined) { - const reference = ctx.stylize(``, "special"); + const reference = ctx.stylize(``, 'special'); // Add reference always to the very beginning of the output. if (ctx.compact !== true) { - base = base === "" ? reference : `${reference} ${base}`; + base = base === '' ? reference : `${reference} ${base}`; } else { braces![0] = `${reference} ${braces![0]}`; } @@ -1313,7 +1125,8 @@ function formatRaw( } } - const res = reduceToSingleString(ctx, output, base, braces!, extrasType, recurseTimes, value); + const res = reduceToSingleString( + ctx, output, base, braces!, extrasType, recurseTimes, value); const budget = ctx.budget[ctx.indentationLvl] || 0; const newLength = budget + res.length; ctx.budget[ctx.indentationLvl] = newLength; @@ -1332,65 +1145,61 @@ function formatRaw( function getIteratorBraces(type: string, tag: string): [string, string] { if (tag !== `${type} Iterator`) { - if (tag !== "") tag += "] ["; + if (tag !== '') + tag += '] ['; tag += `${type} Iterator`; } - return [`[${tag}] {`, "}"]; + return [`[${tag}] {`, '}']; } -function getBoxedBase( - value: unknown, - ctx: Context, - keys: PropertyKey[], - constructor: string | null, - tag: string -): string { +function getBoxedBase(value: unknown, ctx: Context, keys: PropertyKey[], constructor: string | null, tag: string): string { let fn: (this: unknown) => Primitive; let type: Capitalize> | "BigInt"; if (isNumberObject(value)) { fn = Number.prototype.valueOf; - type = "Number"; + type = 'Number'; } else if (isStringObject(value)) { fn = String.prototype.valueOf; - type = "String"; + type = 'String'; // For boxed Strings, we have to remove the 0-n indexed entries, // since they just noisy up the output and are redundant // Make boxed primitive Strings look like such keys.splice(0, value.length); } else if (isBooleanObject(value)) { fn = Boolean.prototype.valueOf; - type = "Boolean"; + type = 'Boolean'; } else if (isBigIntObject(value)) { fn = BigInt.prototype.valueOf; - type = "BigInt"; + type = 'BigInt'; } else { fn = Symbol.prototype.valueOf; - type = "Symbol"; + type = 'Symbol'; } let base = `[${type}`; if (type !== constructor) { if (constructor === null) { - base += " (null prototype)"; + base += ' (null prototype)'; } else { base += ` (${constructor})`; } } base += `: ${formatPrimitive(stylizeNoColor, fn.call(value), ctx)}]`; - if (tag !== "" && tag !== constructor) { + if (tag !== '' && tag !== constructor) { base += ` [${tag}]`; } - if (keys.length !== 0 || ctx.stylize === stylizeNoColor) return base; + if (keys.length !== 0 || ctx.stylize === stylizeNoColor) + return base; return ctx.stylize(base, type.toLowerCase() as Style); } function getClassBase(value: any, constructor: string | null, tag: string): string { - const hasName = Object.prototype.hasOwnProperty.call(value, "name"); - const name = (hasName && value.name) || "(anonymous)"; + const hasName = Object.prototype.hasOwnProperty.call(value, 'name'); + const name = (hasName && value.name) || '(anonymous)'; let base = `class ${name}`; - if (constructor !== "Function" && constructor !== null) { + if (constructor !== 'Function' && constructor !== null) { base += ` [${constructor}]`; } - if (tag !== "" && constructor !== tag) { + if (tag !== '' && constructor !== tag) { base += ` [${tag}]`; } if (constructor !== null) { @@ -1399,26 +1208,25 @@ function getClassBase(value: any, constructor: string | null, tag: string): stri base += ` extends ${superName}`; } } else { - base += " extends [null prototype]"; + base += ' extends [null prototype]'; } return `[${base}]`; } function getFunctionBase(value: Function, constructor: string | null, tag: string): string { const stringified = Function.prototype.toString.call(value); - if (stringified.startsWith("class") && stringified.endsWith("}")) { + if (stringified.startsWith('class') && stringified.endsWith('}')) { const slice = stringified.slice(5, -1); - const bracketIndex = slice.indexOf("{"); - if ( - bracketIndex !== -1 && - (!slice.slice(0, bracketIndex).includes("(") || + const bracketIndex = slice.indexOf('{'); + if (bracketIndex !== -1 && + (!slice.slice(0, bracketIndex).includes('(') || // Slow path to guarantee that it's indeed a class. classRegExp.exec(slice.replace(stripCommentsRegExp, "")) !== null) ) { return getClassBase(value, constructor, tag); } } - let type = "Function"; + let type = 'Function'; if (isGeneratorFunction(value)) { type = `Generator${type}`; } @@ -1427,27 +1235,24 @@ function getFunctionBase(value: Function, constructor: string | null, tag: strin } let base = `[${type}`; if (constructor === null) { - base += " (null prototype)"; + base += ' (null prototype)'; } - if (value.name === "") { - base += " (anonymous)"; + if (value.name === '') { + base += ' (anonymous)'; } else { base += `: ${value.name}`; } - base += "]"; + base += ']'; if (constructor !== type && constructor !== null) { base += ` ${constructor}`; } - if (tag !== "" && constructor !== tag) { + if (tag !== '' && constructor !== tag) { base += ` [${tag}]`; } return base; } -export function identicalSequenceRange( - a: unknown[], - b: unknown[] -): { len: number; offset: number } { +export function identicalSequenceRange(a: unknown[], b: unknown[]): { len: number, offset: number } { for (let i = 0; i < a.length - 3; i++) { // Find the first entry of b that matches the current entry of a. const pos = b.indexOf(a[i]); @@ -1475,7 +1280,7 @@ function getStackString(error: Error): string { } function getStackFrames(ctx: Context, err: Error, stack: string): string[] { - const frames = stack.split("\n"); + const frames = stack.split('\n'); let cause; try { @@ -1487,44 +1292,36 @@ function getStackFrames(ctx: Context, err: Error, stack: string): string[] { // Remove stack frames identical to frames in cause. if (cause != null && isError(cause)) { const causeStack = getStackString(cause); - const causeStackStart = causeStack.indexOf("\n at"); + const causeStackStart = causeStack.indexOf('\n at'); if (causeStackStart !== -1) { - const causeFrames = causeStack.slice(causeStackStart + 1).split("\n"); + const causeFrames = causeStack.slice(causeStackStart + 1).split('\n'); const { len, offset } = identicalSequenceRange(frames, causeFrames); if (len > 0) { const skipped = len - 2; const msg = ` ... ${skipped} lines matching cause stack trace ...`; - frames.splice(offset + 1, skipped, ctx.stylize(msg, "undefined")); + frames.splice(offset + 1, skipped, ctx.stylize(msg, 'undefined')); } } } return frames; } -function improveStack( - stack: string, - constructor: string | null, - name: string, - tag: string -): string { +function improveStack(stack: string, constructor: string | null, name: string, tag: string): string { // A stack trace may contain arbitrary data. Only manipulate the output // for "regular errors" (errors that "look normal") for now. let len = name.length; - if ( - constructor === null || - (name.endsWith("Error") && + if (constructor === null || + (name.endsWith('Error') && stack.startsWith(name) && - (stack.length === len || stack[len] === ":" || stack[len] === "\n")) - ) { - let fallback = "Error"; + (stack.length === len || stack[len] === ':' || stack[len] === '\n'))) { + let fallback = 'Error'; if (constructor === null) { - const start = - /^([A-Z][a-z_ A-Z0-9[\]()-]+)(?::|\n {4}at)/.exec(stack) || + const start = /^([A-Z][a-z_ A-Z0-9[\]()-]+)(?::|\n {4}at)/.exec(stack) || /^([a-z_A-Z0-9-]*Error)$/.exec(stack); - fallback = (start && start[1]) || ""; + fallback = (start && start[1]) || ''; len = fallback.length; - fallback = fallback || "Error"; + fallback = fallback || 'Error'; } const prefix = getPrefix(constructor, tag, fallback).slice(0, -1); if (name !== prefix) { @@ -1542,14 +1339,9 @@ function improveStack( return stack; } -function removeDuplicateErrorKeys( - ctx: Context, - keys: PropertyKey[], - err: Error, - stack: string -): void { +function removeDuplicateErrorKeys(ctx: Context, keys: PropertyKey[], err: Error, stack: string): void { if (!ctx.showHidden && keys.length !== 0) { - for (const name of ["name", "message", "stack"] as const) { + for (const name of ['name', 'message', 'stack'] as const) { const index = keys.indexOf(name); // Only hide the property in case it's part of the original stack if (index !== -1 && stack.includes(err[name]!)) { @@ -1560,13 +1352,13 @@ function removeDuplicateErrorKeys( } function markNodeModules(ctx: Context, line: string): string { - let tempLine = ""; + let tempLine = ''; let nodeModule; let pos = 0; while ((nodeModule = nodeModulesRegExp.exec(line)) !== null) { // '/node_modules/'.length === 14 tempLine += line.slice(pos, nodeModule.index + 14); - tempLine += ctx.stylize(nodeModule[1]!, "module"); + tempLine += ctx.stylize(nodeModule[1]!, 'module'); pos = nodeModule.index + nodeModule[0].length; } if (pos !== 0) { @@ -1575,37 +1367,31 @@ function markNodeModules(ctx: Context, line: string): string { return line; } -function formatError( - err: Error, - constructor: string | null, - tag: string, - ctx: Context, - keys: PropertyKey[] -): string { - const name = err.name != null ? String(err.name) : "Error"; +function formatError(err: Error, constructor: string | null, tag: string, ctx: Context, keys: PropertyKey[]): string { + const name = err.name != null ? String(err.name) : 'Error'; let stack = getStackString(err); removeDuplicateErrorKeys(ctx, keys, err, stack); - if ("cause" in err && (keys.length === 0 || !keys.includes("cause"))) { - keys.push("cause"); + if ('cause' in err && + (keys.length === 0 || !keys.includes('cause'))) { + keys.push('cause'); } // Print errors aggregated into AggregateError - if ( - Array.isArray((err as { errors?: unknown }).errors) && - (keys.length === 0 || !keys.includes("errors")) - ) { - keys.push("errors"); + if (Array.isArray((err as { errors?: unknown }).errors) && + (keys.length === 0 || !keys.includes('errors'))) { + keys.push('errors'); } stack = improveStack(stack, constructor, name, tag); // Ignore the error message if it's contained in the stack. let pos = (err.message && stack.indexOf(err.message)) || -1; - if (pos !== -1) pos += err.message.length; + if (pos !== -1) + pos += err.message.length; // Wrap the error in brackets in case it has no stack trace. - const stackStart = stack.indexOf("\n at", pos); + const stackStart = stack.indexOf('\n at', pos); if (stackStart === -1) { stack = `[${stack}]`; } else { @@ -1615,30 +1401,26 @@ function formatError( if (ctx.colors) { // Highlight userland code and node modules. for (let line of lines) { - newStack += "\n"; + newStack += '\n'; line = markNodeModules(ctx, line); newStack += line; } } else { - newStack += `\n${lines.join("\n")}`; + newStack += `\n${lines.join('\n')}`; } stack = newStack; } // The message and the stack have to be indented as well! if (ctx.indentationLvl !== 0) { - const indentation = " ".repeat(ctx.indentationLvl); - stack = stack.replaceAll("\n", `\n${indentation}`); + const indentation = ' '.repeat(ctx.indentationLvl); + stack = stack.replaceAll('\n', `\n${indentation}`); } return stack; } -function groupArrayElements( - ctx: Context, - output: string[], - value: unknown[] | undefined -): string[] { +function groupArrayElements(ctx: Context, output: string[], value: unknown[] | undefined): string[] { let totalLength = 0; let maxLength = 0; let i = 0; @@ -1656,7 +1438,8 @@ function groupArrayElements( const len = getStringWidth(output[i]!, ctx.colors); dataLen[i] = len; totalLength += len + separatorSpace; - if (maxLength < len) maxLength = len; + if (maxLength < len) + maxLength = len; } // Add two to `maxLength` as we add a single whitespace character plus a comma // in-between two entries. @@ -1665,10 +1448,9 @@ function groupArrayElements( // of arrays that contains entries of very different length (i.e., if a single // entry is longer than 1/5 of all other entries combined). Otherwise the // space in-between small entries would be enormous. - if ( - actualMax * 3 + ctx.indentationLvl < ctx.breakLength && - (totalLength / actualMax > 5 || maxLength <= 6) - ) { + if (actualMax * 3 + ctx.indentationLvl < ctx.breakLength && + (totalLength / actualMax > 5 || maxLength <= 6)) { + const approxCharHeights = 2.5; const averageBias = Math.sqrt(actualMax - totalLength / output.length); const biasedMax = Math.max(actualMax - 3 - averageBias, 1); @@ -1679,18 +1461,18 @@ function groupArrayElements( // which contains n rectangles of size `actualMax * approxCharHeights`. // Divide that by `actualMax` to receive the correct number of columns. // The added bias increases the columns for short entries. - Math.round(Math.sqrt(approxCharHeights * biasedMax * outputLength) / biasedMax), + Math.round( + Math.sqrt( + approxCharHeights * biasedMax * outputLength, + ) / biasedMax, + ), // Do not exceed the breakLength. Math.floor((ctx.breakLength - ctx.indentationLvl) / actualMax), // Limit array grouping for small `compact` modes as the user requested // minimal grouping. - (ctx.compact === false - ? 0 - : ctx.compact === true - ? inspectDefaultOptions.compact - : ctx.compact) * 4, + (ctx.compact === false ? 0 : ctx.compact === true ? inspectDefaultOptions.compact : ctx.compact) * 4, // Limit the columns to a maximum of fifteen. - 15 + 15, ); // Return with the original output if no grouping should happen. if (columns <= 1) { @@ -1701,7 +1483,8 @@ function groupArrayElements( for (let i = 0; i < columns; i++) { let lineMaxLength = 0; for (let j = i; j < output.length; j += columns) { - if (dataLen[j] > lineMaxLength) lineMaxLength = dataLen[j]; + if (dataLen[j] > lineMaxLength) + lineMaxLength = dataLen[j]; } lineMaxLength += separatorSpace; maxLineLength[i] = lineMaxLength; @@ -1709,7 +1492,7 @@ function groupArrayElements( let order = String.prototype.padStart; if (value !== undefined) { for (let i = 0; i < output.length; i++) { - if (typeof value[i] !== "number" && typeof value[i] !== "bigint") { + if (typeof value[i] !== 'number' && typeof value[i] !== 'bigint') { order = String.prototype.padEnd; break; } @@ -1719,19 +1502,21 @@ function groupArrayElements( for (let i = 0; i < outputLength; i += columns) { // The last lines may contain less entries than columns. const max = Math.min(i + columns, outputLength); - let str = ""; + let str = ''; let j = i; for (; j < max - 1; j++) { // Calculate extra color padding in case it's active. This has to be // done line by line as some lines might contain more colors than // others. const padding = maxLineLength[j - i]! + output[j]!.length - dataLen[j]; - str += order.call(`${output[j]}, `, padding, " "); + str += order.call(`${output[j]}, `, padding, ' '); } if (order === String.prototype.padStart) { - const padding = - maxLineLength[j - i]! + output[j]!.length - dataLen[j] - separatorSpace; - str += output[j]!.padStart(padding, " "); + const padding = maxLineLength[j - i]! + + output[j]!.length - + dataLen[j] - + separatorSpace; + str += output[j]!.padStart(padding, ' '); } else { str += output[j]; } @@ -1745,19 +1530,14 @@ function groupArrayElements( return output; } -function handleMaxCallStackSize( - ctx: Context, - err: Error, - constructorName: string, - indentationLvl: number -): string { +function handleMaxCallStackSize(ctx: Context, err: Error, constructorName: string, indentationLvl: number): string { if (isStackOverflowError(err)) { ctx.seen.pop(); ctx.indentationLvl = indentationLvl; return ctx.stylize( `[${constructorName}: Inspection interrupted ` + - "prematurely. Maximum call stack size exceeded.]", - "special" + 'prematurely. Maximum call stack size exceeded.]', + 'special', ); } /* c8 ignore next */ @@ -1765,129 +1545,119 @@ function handleMaxCallStackSize( } function addNumericSeparator(integerString: string): string { - let result = ""; + let result = ''; let i = integerString.length; - const start = integerString.startsWith("-") ? 1 : 0; + const start = integerString.startsWith('-') ? 1 : 0; for (; i >= start + 4; i -= 3) { result = `_${integerString.slice(i - 3, i)}${result}`; } - return i === integerString.length ? integerString : `${integerString.slice(0, i)}${result}`; + return i === integerString.length ? + integerString : + `${integerString.slice(0, i)}${result}`; } function addNumericSeparatorEnd(integerString: string): string { - let result = ""; + let result = ''; let i = 0; for (; i < integerString.length - 3; i += 3) { result += `${integerString.slice(i, i + 3)}_`; } - return i === 0 ? integerString : `${result}${integerString.slice(i)}`; + return i === 0 ? + integerString : + `${result}${integerString.slice(i)}`; } -const remainingText = (remaining: number) => - `... ${remaining} more item${remaining > 1 ? "s" : ""}`; +const remainingText = (remaining: number) => `... ${remaining} more item${remaining > 1 ? 's' : ''}`; -function formatNumber( - fn: InspectOptionsStylized["stylize"], - number: number, - numericSeparator?: boolean -): string { +function formatNumber(fn: InspectOptionsStylized["stylize"], number: number, numericSeparator?: boolean): string { if (!numericSeparator) { // Format -0 as '-0'. Checking `number === -0` won't distinguish 0 from -0. if (Object.is(number, -0)) { - return fn("-0", "number"); + return fn('-0', 'number'); } - return fn(`${number}`, "number"); + return fn(`${number}`, 'number'); } const integer = Math.trunc(number); const string = String(integer); if (integer === number) { - if (!Number.isFinite(number) || string.includes("e")) { - return fn(string, "number"); + if (!Number.isFinite(number) || string.includes('e')) { + return fn(string, 'number'); } - return fn(`${addNumericSeparator(string)}`, "number"); + return fn(`${addNumericSeparator(string)}`, 'number'); } if (Number.isNaN(number)) { - return fn(string, "number"); + return fn(string, 'number'); } - return fn( - `${addNumericSeparator(string)}.${addNumericSeparatorEnd( - String(number).slice(string.length + 1) - )}`, - "number" - ); + return fn(`${ + addNumericSeparator(string) + }.${ + addNumericSeparatorEnd( + String(number).slice(string.length + 1), + ) + }`, 'number'); } -function formatBigInt( - fn: InspectOptionsStylized["stylize"], - bigint: bigint, - numericSeparator?: boolean -): string { +function formatBigInt(fn: InspectOptionsStylized["stylize"], bigint: bigint, numericSeparator?: boolean): string { const string = String(bigint); if (!numericSeparator) { - return fn(`${string}n`, "bigint"); + return fn(`${string}n`, 'bigint'); } - return fn(`${addNumericSeparator(string)}n`, "bigint"); + return fn(`${addNumericSeparator(string)}n`, 'bigint'); } type Primitive = string | number | bigint | boolean | undefined | symbol; -function formatPrimitive( - fn: InspectOptionsStylized["stylize"], - value: Primitive, - ctx: Context -): string { - if (typeof value === "string") { - let trailer = ""; +function formatPrimitive(fn: InspectOptionsStylized["stylize"], value: Primitive, ctx: Context): string { + if (typeof value === 'string') { + let trailer = ''; if (ctx.maxStringLength !== null && value.length > ctx.maxStringLength) { const remaining = value.length - ctx.maxStringLength; value = value.slice(0, ctx.maxStringLength); - trailer = `... ${remaining} more character${remaining > 1 ? "s" : ""}`; + trailer = `... ${remaining} more character${remaining > 1 ? 's' : ''}`; } - if ( - ctx.compact !== true && + if (ctx.compact !== true && // We do not support handling unicode characters width with // the readline getStringWidth function as there are // performance implications. value.length > kMinLineLength && - value.length > ctx.breakLength - ctx.indentationLvl - 4 - ) { - return ( - value + value.length > ctx.breakLength - ctx.indentationLvl - 4) { + return value .split(/(?<=\n)/) - .map((line) => fn(strEscape(line), "string")) - .join(` +\n${" ".repeat(ctx.indentationLvl + 2)}`) + trailer - ); - } - return fn(strEscape(value), "string") + trailer; - } - if (typeof value === "number") return formatNumber(fn, value, ctx.numericSeparator); - if (typeof value === "bigint") return formatBigInt(fn, value, ctx.numericSeparator); - if (typeof value === "boolean") return fn(`${value}`, "boolean"); - if (typeof value === "undefined") return fn("undefined", "undefined"); + .map((line) => fn(strEscape(line), 'string')) + .join(` +\n${' '.repeat(ctx.indentationLvl + 2)}`) + + trailer; + } + return fn(strEscape(value), 'string') + trailer; + } + if (typeof value === 'number') + return formatNumber(fn, value, ctx.numericSeparator); + if (typeof value === 'bigint') + return formatBigInt(fn, value, ctx.numericSeparator); + if (typeof value === 'boolean') + return fn(`${value}`, 'boolean'); + if (typeof value === 'undefined') + return fn('undefined', 'undefined'); // es6 symbol primitive - return fn(Symbol.prototype.toString.call(value), "symbol"); + return fn(Symbol.prototype.toString.call(value), 'symbol'); } -function formatNamespaceObject( - keys: PropertyKey[], - ctx: Context, - value: object, - recurseTimes: number -): string[] { +function formatNamespaceObject(keys: PropertyKey[], ctx: Context, value: object, recurseTimes: number): string[] { const output = new Array(keys.length); for (let i = 0; i < keys.length; i++) { try { - output[i] = formatProperty(ctx, value, recurseTimes, keys[i]!, kObjectType); + output[i] = formatProperty(ctx, value, recurseTimes, keys[i]!, + kObjectType); } catch (err) { - assert(isNativeError(err) && err.name === "ReferenceError"); + assert(isNativeError(err) && err.name === 'ReferenceError'); // Use the existing functionality. This makes sure the indentation and // line breaks are always correct. Otherwise it is very difficult to keep // this aligned, even though this is a hacky way of dealing with this. - const tmp = { [keys[i]!]: "" }; + const tmp = { [keys[i]!]: '' }; output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i]!, kObjectType); - const pos = output[i]!.lastIndexOf(" "); + const pos = output[i]!.lastIndexOf(' '); // We have to find the last whitespace and have to replace that value as // it will be visualized as a regular string. - output[i] = output[i]!.slice(0, pos + 1) + ctx.stylize("", "special"); + output[i] = output[i]!.slice(0, pos + 1) + + ctx.stylize('', 'special'); } } // Reset the keys to an empty array. This prevents duplicated inspection. @@ -1896,14 +1666,7 @@ function formatNamespaceObject( } // The array is sparse and/or has extra keys -function formatSpecialArray( - ctx: Context, - value: unknown[], - recurseTimes: number, - maxLength: number, - output: string[], - i: number -): string[] { +function formatSpecialArray(ctx: Context, value: unknown[], recurseTimes: number, maxLength: number, output: string[], i: number): string[] { const keys = Object.keys(value); let index = i; for (; i < keys.length && output.length < maxLength; i++) { @@ -1918,9 +1681,9 @@ function formatSpecialArray( break; } const emptyItems = tmp - index; - const ending = emptyItems > 1 ? "s" : ""; + const ending = emptyItems > 1 ? 's' : ''; const message = `<${emptyItems} empty item${ending}>`; - output.push(ctx.stylize(message, "undefined")); + output.push(ctx.stylize(message, 'undefined')); index = tmp; if (output.length === maxLength) { break; @@ -1932,9 +1695,9 @@ function formatSpecialArray( const remaining = value.length - index; if (output.length !== maxLength) { if (remaining > 0) { - const ending = remaining > 1 ? "s" : ""; + const ending = remaining > 1 ? 's' : ''; const message = `<${remaining} empty item${ending}>`; - output.push(ctx.stylize(message, "undefined")); + output.push(ctx.stylize(message, 'undefined')); } } else if (remaining > 0) { output.push(remainingText(remaining)); @@ -1947,16 +1710,16 @@ function formatArrayBuffer(ctx: Context, value: ArrayBuffer): string[] { try { buffer = new Uint8Array(value); } catch { - return [ctx.stylize("(detached)", "special")]; + return [ctx.stylize('(detached)', 'special')]; } const maxArrayLength = ctx.maxArrayLength; - let str = Buffer.prototype.hexSlice - .call(buffer, 0, Math.min(maxArrayLength, buffer.length)) - .replace(/(.{2})/g, "$1 ") + let str = Buffer.prototype.hexSlice.call(buffer, 0, Math.min(maxArrayLength, buffer.length)) + .replace(/(.{2})/g, '$1 ') .trim(); const remaining = buffer.length - maxArrayLength; - if (remaining > 0) str += ` ... ${remaining} more byte${remaining > 1 ? "s" : ""}`; - return [`${ctx.stylize("[Uint8Contents]", "special")}: <${str}>`]; + if (remaining > 0) + str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`; + return [`${ctx.stylize('[Uint8Contents]', 'special')}: <${str}>`]; } function formatArray(ctx: Context, value: unknown[], recurseTimes: number): string[] { @@ -1978,18 +1741,13 @@ function formatArray(ctx: Context, value: unknown[], recurseTimes: number): stri return output; } -function formatTypedArray( - value: internal.TypedArray, - length: number, - ctx: Context, - _ignored: unknown, - recurseTimes: number -): string[] { +function formatTypedArray(value: internal.TypedArray, length: number, ctx: Context, _ignored: unknown, recurseTimes: number): string[] { const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), length); const remaining = value.length - maxLength; const output = new Array(maxLength); - const elementFormatter = - value.length > 0 && typeof value[0] === "number" ? formatNumber : formatBigInt; + const elementFormatter = value.length > 0 && typeof value[0] === 'number' ? + formatNumber : + formatBigInt; for (let i = 0; i < maxLength; ++i) { // @ts-expect-error `value[i]` assumed to be of correct numeric type output[i] = elementFormatter(ctx.stylize, value[i], ctx.numericSeparator); @@ -2002,11 +1760,11 @@ function formatTypedArray( // All besides `BYTES_PER_ELEMENT` are actually getters. ctx.indentationLvl += 2; for (const key of [ - "BYTES_PER_ELEMENT", - "length", - "byteLength", - "byteOffset", - "buffer", + 'BYTES_PER_ELEMENT', + 'length', + 'byteLength', + 'byteOffset', + 'buffer', ] as const) { const str = formatValue(ctx, value[key], recurseTimes, true); output.push(`[${key}]: ${str}`); @@ -2016,12 +1774,7 @@ function formatTypedArray( return output; } -function formatSet( - value: Set | IterableIterator, - ctx: Context, - _ignored: unknown, - recurseTimes: number -): string[] { +function formatSet(value: Set | IterableIterator, ctx: Context, _ignored: unknown, recurseTimes: number): string[] { const length = isSet(value) ? value.size : NaN; const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), length); const remaining = length - maxLength; @@ -2040,12 +1793,7 @@ function formatSet( return output; } -function formatMap( - value: Map | IterableIterator<[unknown, unknown]>, - ctx: Context, - _ignored: unknown, - recurseTimes: number -): string[] { +function formatMap(value: Map | IterableIterator<[unknown, unknown]>, ctx: Context, _ignored: unknown, recurseTimes: number): string[] { const length = isMap(value) ? value.size : NaN; const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), length); const remaining = length - maxLength; @@ -2054,7 +1802,9 @@ function formatMap( let i = 0; for (const { 0: k, 1: v } of value) { if (i >= maxLength) break; - output.push(`${formatValue(ctx, k, recurseTimes)} => ${formatValue(ctx, v, recurseTimes)}`); + output.push( + `${formatValue(ctx, k, recurseTimes)} => ${formatValue(ctx, v, recurseTimes)}` + ); i++; } if (remaining > 0) { @@ -2064,12 +1814,7 @@ function formatMap( return output; } -function formatSetIterInner( - ctx: Context, - recurseTimes: number, - entries: unknown[], - state: number -): string[] { +function formatSetIterInner(ctx: Context, recurseTimes: number, entries: unknown[], state: number): string[] { const maxArrayLength = Math.max(ctx.maxArrayLength, 0); const maxLength = Math.min(maxArrayLength, entries.length); const output = new Array(maxLength); @@ -2091,12 +1836,7 @@ function formatSetIterInner( return output; } -function formatMapIterInner( - ctx: Context, - recurseTimes: number, - entries: unknown[], - state: number -): string[] { +function formatMapIterInner(ctx: Context, recurseTimes: number, entries: unknown[], state: number): string[] { const maxArrayLength = Math.max(ctx.maxArrayLength, 0); // Entries exist as [key1, val1, key2, val2, ...] const len = entries.length / 2; @@ -2108,16 +1848,14 @@ function formatMapIterInner( if (state === kWeak) { for (; i < maxLength; i++) { const pos = i * 2; - output[i] = `${formatValue(ctx, entries[pos], recurseTimes)} => ${formatValue( - ctx, - entries[pos + 1], - recurseTimes - )}`; + output[i] = + `${formatValue(ctx, entries[pos], recurseTimes)} => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`; } // Sort all entries to have a halfway reliable output (if more entries than // retrieved ones exist, we can not reliably return the same output) if the // output is not sorted anyway. - if (!ctx.sorted) output.sort(); + if (!ctx.sorted) + output.sort(); } else { for (; i < maxLength; i++) { const pos = i * 2; @@ -2126,13 +1864,7 @@ function formatMapIterInner( formatValue(ctx, entries[pos + 1], recurseTimes), ]; output[i] = reduceToSingleString( - ctx, - res, - "", - ["[", "]"], - kArrayExtrasType, - recurseTimes - ); + ctx, res, '', ['[', ']'], kArrayExtrasType, recurseTimes); } } ctx.indentationLvl -= 2; @@ -2143,7 +1875,7 @@ function formatMapIterInner( } function formatWeakCollection(ctx: Context): string[] { - return [ctx.stylize("", "special")]; + return [ctx.stylize('', 'special')]; } function formatWeakSet(ctx: Context, value: WeakSet, recurseTimes: number): string[] { @@ -2156,16 +1888,11 @@ function formatWeakMap(ctx: Context, value: WeakMap, recurseTimes: return formatMapIterInner(ctx, recurseTimes, entries, kWeak); } -function formatIterator( - braces: [string, string], - ctx: Context, - value: Iterator, - recurseTimes: number -): string[] { +function formatIterator(braces: [string, string], ctx: Context, value: Iterator, recurseTimes: number): string[] { const { entries, isKeyValue } = internal.previewEntries(value)!; if (isKeyValue) { // Mark entry iterators as such. - braces[0] = braces[0].replace(/ Iterator] {$/, " Entries] {"); + braces[0] = braces[0].replace(/ Iterator] {$/, ' Entries] {'); return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries); } @@ -2176,93 +1903,80 @@ function formatPromise(ctx: Context, value: Promise, recurseTimes: numb let output: string[]; const { state, result } = internal.getPromiseDetails(value)!; if (state === internal.kPending) { - output = [ctx.stylize("", "special")]; + output = [ctx.stylize('', 'special')]; } else { ctx.indentationLvl += 2; const str = formatValue(ctx, result, recurseTimes); ctx.indentationLvl -= 2; output = [ - state === internal.kRejected ? `${ctx.stylize("", "special")} ${str}` : str, + state === internal.kRejected ? + `${ctx.stylize('', 'special')} ${str}` : + str, ]; } return output; } -function formatProperty( - ctx: Context, - value: object, - recurseTimes: number, - key: PropertyKey, - type: number, - desc?: PropertyDescriptor, - original = value -): string { +function formatProperty(ctx: Context, value: object, recurseTimes: number, key: PropertyKey, type: number, desc?: PropertyDescriptor, + original = value): string { let name: string, str: string; - let extra = " "; - desc = desc || - Object.getOwnPropertyDescriptor(value, key) || { - value: (value as Record)[key], - enumerable: true, - }; + let extra = ' '; + desc = desc || Object.getOwnPropertyDescriptor(value, key) || + { value: (value as Record)[key], enumerable: true }; if (desc.value !== undefined) { - const diff = ctx.compact !== true || type !== kObjectType ? 2 : 3; + const diff = (ctx.compact !== true || type !== kObjectType) ? 2 : 3; ctx.indentationLvl += diff; str = formatValue(ctx, desc.value, recurseTimes); if (diff === 3 && ctx.breakLength < getStringWidth(str, ctx.colors)) { - extra = `\n${" ".repeat(ctx.indentationLvl)}`; + extra = `\n${' '.repeat(ctx.indentationLvl)}`; } ctx.indentationLvl -= diff; } else if (desc.get !== undefined) { - const label = desc.set !== undefined ? "Getter/Setter" : "Getter"; + const label = desc.set !== undefined ? 'Getter/Setter' : 'Getter'; const s = ctx.stylize; - const sp = "special"; - if ( - ctx.getters && - (ctx.getters === true || - (ctx.getters === "get" && desc.set === undefined) || - (ctx.getters === "set" && desc.set !== undefined)) - ) { + const sp = 'special'; + if (ctx.getters && (ctx.getters === true || + (ctx.getters === 'get' && desc.set === undefined) || + (ctx.getters === 'set' && desc.set !== undefined))) { try { const tmp = desc.get.call(original); ctx.indentationLvl += 2; if (tmp === null) { - str = `${s(`[${label}:`, sp)} ${s("null", "null")}${s("]", sp)}`; - } else if (typeof tmp === "object") { + str = `${s(`[${label}:`, sp)} ${s('null', 'null')}${s(']', sp)}`; + } else if (typeof tmp === 'object') { str = `${s(`[${label}]`, sp)} ${formatValue(ctx, tmp, recurseTimes)}`; } else { const primitive = formatPrimitive(s, tmp, ctx); - str = `${s(`[${label}:`, sp)} ${primitive}${s("]", sp)}`; + str = `${s(`[${label}:`, sp)} ${primitive}${s(']', sp)}`; } ctx.indentationLvl -= 2; } catch (err) { const message = ``; - str = `${s(`[${label}:`, sp)} ${message}${s("]", sp)}`; + str = `${s(`[${label}:`, sp)} ${message}${s(']', sp)}`; } } else { str = ctx.stylize(`[${label}]`, sp); } } else if (desc.set !== undefined) { - str = ctx.stylize("[Setter]", "special"); + str = ctx.stylize('[Setter]', 'special'); } else { - str = ctx.stylize("undefined", "undefined"); + str = ctx.stylize('undefined', 'undefined'); } if (type === kArrayType) { return str; } - if (typeof key === "symbol") { - const tmp = Symbol.prototype.toString - .call(key) - .replace(strEscapeSequencesReplacer, escapeFn); - name = `[${ctx.stylize(tmp, "symbol")}]`; - } else if (key === "__proto__") { + if (typeof key === 'symbol') { + const tmp = Symbol.prototype.toString.call(key).replace(strEscapeSequencesReplacer, escapeFn); + name = `[${ctx.stylize(tmp, 'symbol')}]`; + } else if (key === '__proto__') { name = "['__proto__']"; } else if (desc.enumerable === false) { const tmp = String(key).replace(strEscapeSequencesReplacer, escapeFn); name = `[${tmp}]`; } else if (keyStrRegExp.exec(String(key)) !== null) { - name = ctx.stylize(String(key), "name"); + name = ctx.stylize(String(key), 'name'); } else { - name = ctx.stylize(strEscape(String(key)), "string"); + name = ctx.stylize(strEscape(String(key)), 'string'); } return `${name}:${extra}${str}`; } @@ -2275,7 +1989,8 @@ function isBelowBreakLength(ctx: Context, output: string[], start: number, base: // function. Check the performance overhead and make it an opt-in in case it's // significant. let totalLength = output.length + start; - if (totalLength + output.length > ctx.breakLength) return false; + if (totalLength + output.length > ctx.breakLength) + return false; for (let i = 0; i < output.length; i++) { if (ctx.colors) { totalLength += removeColors(output[i]!).length; @@ -2287,20 +2002,13 @@ function isBelowBreakLength(ctx: Context, output: string[], start: number, base: } } // Do not line up properties on the same line if `base` contains line breaks. - return base === "" || !base.includes("\n"); + return base === '' || !base.includes('\n'); } function reduceToSingleString( - ctx: Context, - output: string[], - base: string, - braces: [string, string], - extrasType: number, - recurseTimes: number, - value?: unknown -): string { + ctx: Context, output: string[], base: string, braces: [string, string], extrasType: number, recurseTimes: number, value?: unknown): string { if (ctx.compact !== true) { - if (typeof ctx.compact === "number" && ctx.compact >= 1) { + if (typeof ctx.compact === 'number' && ctx.compact >= 1) { // Memorize the original output length. In case the output is grouped, // prevent lining up the entries on a single line. const entries = output.length; @@ -2323,41 +2031,39 @@ function reduceToSingleString( // Consolidate all entries of the local most inner depth up to // `ctx.compact`, as long as the properties are smaller than // `ctx.breakLength`. - if (ctx.currentDepth - recurseTimes < ctx.compact && entries === output.length) { + if (ctx.currentDepth - recurseTimes < ctx.compact && + entries === output.length) { // Line up all entries on a single line in case the entries do not // exceed `breakLength`. Add 10 as constant to start next to all other // factors that may reduce `breakLength`. - const start = - output.length + ctx.indentationLvl + braces[0].length + base.length + 10; + const start = output.length + ctx.indentationLvl + + braces[0].length + base.length + 10; if (isBelowBreakLength(ctx, output, start, base)) { - const joinedOutput = output.join(", "); - if (!joinedOutput.includes("\n")) { - return ( - `${base ? `${base} ` : ""}${braces[0]} ${joinedOutput}` + - ` ${braces[1]}` - ); + const joinedOutput = output.join(', '); + if (!joinedOutput.includes('\n')) { + return `${base ? `${base} ` : ''}${braces[0]} ${joinedOutput}` + + ` ${braces[1]}`; } } } } // Line up each entry on an individual line. - const indentation = `\n${" ".repeat(ctx.indentationLvl)}`; - return ( - `${base ? `${base} ` : ""}${braces[0]}${indentation} ` + - `${output.join(`,${indentation} `)}${indentation}${braces[1]}` - ); + const indentation = `\n${' '.repeat(ctx.indentationLvl)}`; + return `${base ? `${base} ` : ''}${braces[0]}${indentation} ` + + `${output.join(`,${indentation} `)}${indentation}${braces[1]}`; } // Line up all entries on a single line in case the entries do not exceed // `breakLength`. if (isBelowBreakLength(ctx, output, 0, base)) { - return `${braces[0]}${base ? ` ${base}` : ""} ${output.join(", ")} ` + braces[1]; + return `${braces[0]}${base ? ` ${base}` : ''} ${output.join(', ')} ` + + braces[1]; } - const indentation = " ".repeat(ctx.indentationLvl); + const indentation = ' '.repeat(ctx.indentationLvl); // If the opening "brace" is too large, like in the case of "Set {", // we need to force the first item to be on the next line or the // items will not line up correctly. - const ln = - base === "" && braces[0].length === 1 ? " " : `${base ? ` ${base}` : ""}\n${indentation} `; + const ln = base === '' && braces[0].length === 1 ? + ' ' : `${base ? ` ${base}` : ''}\n${indentation} `; // Line up each entry on an individual line. return `${braces[0]}${ln}${output.join(`,\n${indentation} `)} ${braces[1]}`; } @@ -2373,12 +2079,12 @@ function hasBuiltInToString(value: object): boolean { } // Count objects that have no `toString` function as built-in. - if (typeof value?.toString !== "function") { + if (typeof value?.toString !== 'function') { return true; } // The object has a own `toString` property. Thus it's not not a built-in one. - if (Object.prototype.hasOwnProperty.call(value, "toString")) { + if (Object.prototype.hasOwnProperty.call(value, 'toString')) { return false; } @@ -2387,19 +2093,16 @@ function hasBuiltInToString(value: object): boolean { let pointer = value; do { pointer = Object.getPrototypeOf(pointer); - } while (!Object.prototype.hasOwnProperty.call(pointer, "toString")); + } while (!Object.prototype.hasOwnProperty.call(pointer, 'toString')); // Check closer if the object is a built-in. - const descriptor = Object.getOwnPropertyDescriptor(pointer, "constructor"); - return ( - descriptor !== undefined && - typeof descriptor.value === "function" && - builtInObjects.has(descriptor.value.name) - ); + const descriptor = Object.getOwnPropertyDescriptor(pointer, 'constructor'); + return descriptor !== undefined && + typeof descriptor.value === 'function' && + builtInObjects.has(descriptor.value.name); } -const firstErrorLine = (error: unknown) => - (isError(error) ? error.message : String(error)).split("\n", 1)[0]; +const firstErrorLine = (error: unknown) => (isError(error) ? error.message : String(error)).split('\n', 1)[0]; let CIRCULAR_ERROR_MESSAGE: string | undefined; function tryStringify(arg: unknown): string { try { @@ -2415,14 +2118,9 @@ function tryStringify(arg: unknown): string { CIRCULAR_ERROR_MESSAGE = firstErrorLine(circularError); } } - if ( - typeof err === "object" && - err !== null && - "name" in err && - err.name === "TypeError" && - firstErrorLine(err) === CIRCULAR_ERROR_MESSAGE - ) { - return "[Circular]"; + if (typeof err === "object" && err !== null && "name" in err && err.name === 'TypeError' && + firstErrorLine(err) === CIRCULAR_ERROR_MESSAGE) { + return '[Circular]'; } throw err; } @@ -2433,7 +2131,7 @@ export function format(...args: unknown[]): string { } export function formatWithOptions(inspectOptions: InspectOptions, ...args: unknown[]): string { - validateObject(inspectOptions, "inspectOptions", { allowArray: true }); + validateObject(inspectOptions, 'inspectOptions', { allowArray: true }); return formatWithOptionsInternal(inspectOptions, args); } @@ -2441,7 +2139,7 @@ function formatNumberNoColor(number: number, options?: InspectOptions): string { return formatNumber( stylizeNoColor, number, - options?.numericSeparator ?? inspectDefaultOptions.numericSeparator + options?.numericSeparator ?? inspectDefaultOptions.numericSeparator, ); } @@ -2449,20 +2147,17 @@ function formatBigIntNoColor(bigint: bigint, options?: InspectOptions): string { return formatBigInt( stylizeNoColor, bigint, - options?.numericSeparator ?? inspectDefaultOptions.numericSeparator + options?.numericSeparator ?? inspectDefaultOptions.numericSeparator, ); } -function formatWithOptionsInternal( - inspectOptions: InspectOptions | undefined, - args: unknown[] -): string { +function formatWithOptionsInternal(inspectOptions: InspectOptions | undefined, args: unknown[]): string { const first = args[0]; let a = 0; - let str = ""; - let join = ""; + let str = ''; + let join = ''; - if (typeof first === "string") { + if (typeof first === 'string') { if (args.length === 1) { return first; } @@ -2470,23 +2165,19 @@ function formatWithOptionsInternal( let lastPos = 0; for (let i = 0; i < first.length - 1; i++) { - if (first.charCodeAt(i) === 37) { - // '%' + if (first.charCodeAt(i) === 37) { // '%' const nextChar = first.charCodeAt(++i); if (a + 1 !== args.length) { switch (nextChar) { - case 115: { - // 's' + case 115: { // 's' const tempArg = args[++a]; - if (typeof tempArg === "number") { + if (typeof tempArg === 'number') { tempStr = formatNumberNoColor(tempArg, inspectOptions); - } else if (typeof tempArg === "bigint") { + } else if (typeof tempArg === 'bigint') { tempStr = formatBigIntNoColor(tempArg, inspectOptions); - } else if ( - typeof tempArg !== "object" || + } else if (typeof tempArg !== 'object' || tempArg === null || - !hasBuiltInToString(tempArg) - ) { + !hasBuiltInToString(tempArg)) { tempStr = String(tempArg); } else { tempStr = inspect(tempArg, { @@ -2501,13 +2192,12 @@ function formatWithOptionsInternal( case 106: // 'j' tempStr = tryStringify(args[++a]); break; - case 100: { - // 'd' + case 100: { // 'd' const tempNum = args[++a]; - if (typeof tempNum === "bigint") { + if (typeof tempNum === 'bigint') { tempStr = formatBigIntNoColor(tempNum, inspectOptions); - } else if (typeof tempNum === "symbol") { - tempStr = "NaN"; + } else if (typeof tempNum === 'symbol') { + tempStr = 'NaN'; } else { tempStr = formatNumberNoColor(Number(tempNum), inspectOptions); } @@ -2524,37 +2214,31 @@ function formatWithOptionsInternal( depth: 4, }); break; - case 105: { - // 'i' + case 105: { // 'i' const tempInteger = args[++a]; - if (typeof tempInteger === "bigint") { + if (typeof tempInteger === 'bigint') { tempStr = formatBigIntNoColor(tempInteger, inspectOptions); - } else if (typeof tempInteger === "symbol") { - tempStr = "NaN"; + } else if (typeof tempInteger === 'symbol') { + tempStr = 'NaN'; } else { tempStr = formatNumberNoColor( - Number.parseInt(tempInteger as unknown as string), - inspectOptions - ); + Number.parseInt(tempInteger as unknown as string), inspectOptions); } break; } - case 102: { - // 'f' + case 102: { // 'f' const tempFloat = args[++a]; - if (typeof tempFloat === "symbol") { - tempStr = "NaN"; + if (typeof tempFloat === 'symbol') { + tempStr = 'NaN'; } else { tempStr = formatNumberNoColor( - Number.parseFloat(tempFloat as unknown as string), - inspectOptions - ); + Number.parseFloat(tempFloat as unknown as string), inspectOptions); } break; } case 99: // 'c' a += 1; - tempStr = ""; + tempStr = ''; break; case 37: // '%' str += first.slice(lastPos, i); @@ -2576,7 +2260,7 @@ function formatWithOptionsInternal( } if (lastPos !== 0) { a++; - join = " "; + join = ' '; if (lastPos < first.length) { str += first.slice(lastPos); } @@ -2586,25 +2270,23 @@ function formatWithOptionsInternal( while (a < args.length) { const value = args[a]; str += join; - str += typeof value !== "string" ? inspect(value, inspectOptions) : value; - join = " "; + str += typeof value !== 'string' ? inspect(value, inspectOptions) : value; + join = ' '; a++; } return str; } export function isZeroWidthCodePoint(code: number): boolean { - return ( - code <= 0x1f || // C0 control codes - (code >= 0x7f && code <= 0x9f) || // C1 control codes - (code >= 0x300 && code <= 0x36f) || // Combining Diacritical Marks - (code >= 0x200b && code <= 0x200f) || // Modifying Invisible Characters + return code <= 0x1F || // C0 control codes + (code >= 0x7F && code <= 0x9F) || // C1 control codes + (code >= 0x300 && code <= 0x36F) || // Combining Diacritical Marks + (code >= 0x200B && code <= 0x200F) || // Modifying Invisible Characters // Combining Diacritical Marks for Symbols - (code >= 0x20d0 && code <= 0x20ff) || - (code >= 0xfe00 && code <= 0xfe0f) || // Variation Selectors - (code >= 0xfe20 && code <= 0xfe2f) || // Combining Half Marks - (code >= 0xe0100 && code <= 0xe01ef) - ); // Variation Selectors + (code >= 0x20D0 && code <= 0x20FF) || + (code >= 0xFE00 && code <= 0xFE0F) || // Variation Selectors + (code >= 0xFE20 && code <= 0xFE2F) || // Combining Half Marks + (code >= 0xE0100 && code <= 0xE01EF); // Variation Selectors } /** @@ -2613,8 +2295,9 @@ export function isZeroWidthCodePoint(code: number): boolean { export function getStringWidth(str: string, removeControlChars = true): number { let width = 0; - if (removeControlChars) str = stripVTControlCharacters(str); - str = str.normalize("NFC"); + if (removeControlChars) + str = stripVTControlCharacters(str); + str = str.normalize('NFC'); for (const char of str) { const code = char.codePointAt(0)!; if (isFullWidthCodePoint(code)) { @@ -2625,7 +2308,7 @@ export function getStringWidth(str: string, removeControlChars = true): number { } return width; -} +}; /** * Returns true if the character represented by a given @@ -2634,39 +2317,38 @@ export function getStringWidth(str: string, removeControlChars = true): number { const isFullWidthCodePoint = (code: number) => { // Code points are partially derived from: // https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt - return ( - code >= 0x1100 && - (code <= 0x115f || // Hangul Jamo - code === 0x2329 || // LEFT-POINTING ANGLE BRACKET - code === 0x232a || // RIGHT-POINTING ANGLE BRACKET - // CJK Radicals Supplement .. Enclosed CJK Letters and Months - (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) || - // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A - (code >= 0x3250 && code <= 0x4dbf) || - // CJK Unified Ideographs .. Yi Radicals - (code >= 0x4e00 && code <= 0xa4c6) || - // Hangul Jamo Extended-A - (code >= 0xa960 && code <= 0xa97c) || - // Hangul Syllables - (code >= 0xac00 && code <= 0xd7a3) || - // CJK Compatibility Ideographs - (code >= 0xf900 && code <= 0xfaff) || - // Vertical Forms - (code >= 0xfe10 && code <= 0xfe19) || - // CJK Compatibility Forms .. Small Form Variants - (code >= 0xfe30 && code <= 0xfe6b) || - // Halfwidth and Fullwidth Forms - (code >= 0xff01 && code <= 0xff60) || - (code >= 0xffe0 && code <= 0xffe6) || - // Kana Supplement - (code >= 0x1b000 && code <= 0x1b001) || - // Enclosed Ideographic Supplement - (code >= 0x1f200 && code <= 0x1f251) || - // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff - // Emoticons 0x1f600 - 0x1f64f - (code >= 0x1f300 && code <= 0x1f64f) || - // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane - (code >= 0x20000 && code <= 0x3fffd)) + return code >= 0x1100 && ( + code <= 0x115f || // Hangul Jamo + code === 0x2329 || // LEFT-POINTING ANGLE BRACKET + code === 0x232a || // RIGHT-POINTING ANGLE BRACKET + // CJK Radicals Supplement .. Enclosed CJK Letters and Months + (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) || + // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A + (code >= 0x3250 && code <= 0x4dbf) || + // CJK Unified Ideographs .. Yi Radicals + (code >= 0x4e00 && code <= 0xa4c6) || + // Hangul Jamo Extended-A + (code >= 0xa960 && code <= 0xa97c) || + // Hangul Syllables + (code >= 0xac00 && code <= 0xd7a3) || + // CJK Compatibility Ideographs + (code >= 0xf900 && code <= 0xfaff) || + // Vertical Forms + (code >= 0xfe10 && code <= 0xfe19) || + // CJK Compatibility Forms .. Small Form Variants + (code >= 0xfe30 && code <= 0xfe6b) || + // Halfwidth and Fullwidth Forms + (code >= 0xff01 && code <= 0xff60) || + (code >= 0xffe0 && code <= 0xffe6) || + // Kana Supplement + (code >= 0x1b000 && code <= 0x1b001) || + // Enclosed Ideographic Supplement + (code >= 0x1f200 && code <= 0x1f251) || + // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff + // Emoticons 0x1f600 - 0x1f64f + (code >= 0x1f300 && code <= 0x1f64f) || + // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane + (code >= 0x20000 && code <= 0x3fffd) ); }; @@ -2674,9 +2356,9 @@ const isFullWidthCodePoint = (code: number) => { * Remove all VT control characters. Use to estimate displayed string width. */ export function stripVTControlCharacters(str: string): string { - validateString(str, "str"); + validateString(str, 'str'); - return str.replace(ansi, ""); + return str.replace(ansi, ''); } // ================================================================================================ @@ -2694,7 +2376,7 @@ export function formatLog(...args: [...values: unknown[], colors: boolean]): str function isBuiltinPrototype(proto: unknown) { if (proto === null) return true; - const descriptor = Object.getOwnPropertyDescriptor(proto, "constructor"); + const descriptor = Object.getOwnPropertyDescriptor(proto, 'constructor'); return ( descriptor !== undefined && typeof descriptor.value === "function" && @@ -2729,7 +2411,7 @@ function formatJsgResourceType( options: InspectOptionsStylized ): unknown { const name = this.constructor.name; - if (depth < 0) return options.stylize(`[${name}]`, "special"); + if (depth < 0) return options.stylize(`[${name}]`, 'special'); // Build a plain object for inspection. If this value has an `entries()` function, add those // entries for map-like `K => V` formatting. Note we can't use a `Map` here as a key may have @@ -2748,7 +2430,7 @@ function formatJsgResourceType( if (typeof value === "function" || this.constructor.propertyIsEnumerable(key)) continue; record[key] = value; } - } while (!isBuiltinPrototype((current = Object.getPrototypeOf(current)))); + } while (!isBuiltinPrototype(current = Object.getPrototypeOf(current))); // Add additional inspect-only properties as non-enumerable so they appear in square brackets for (const [key, symbol] of Object.entries(additionalProperties)) { @@ -2769,4 +2451,4 @@ function formatJsgResourceType( // something like `Headers(1) { 'a' => '1' }`. return `${name}${inspected.replace("Object", "")}`; } -} +} \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_path.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_path.ts index 174193c23..88659773c 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_path.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_path.ts @@ -1,52 +1,54 @@ -import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./constants"; +import { + CHAR_DOT, + CHAR_FORWARD_SLASH, +} from './constants'; -import { validateObject, validateString } from "./validators"; +import { + validateObject, + validateString, +} from './validators'; -function isPosixPathSeparator(code: number) { +function isPosixPathSeparator(code : number) { return code === CHAR_FORWARD_SLASH; } // Resolves . and .. elements in a path with directory names -function normalizeString( - path: string, - allowAboveRoot: boolean, - separator: string, - isPathSeparator: (code: number) => boolean -) { - let res = ""; +function normalizeString(path: string, allowAboveRoot: boolean, separator: string, isPathSeparator: (code:number) => boolean) { + let res = ''; let lastSegmentLength = 0; let lastSlash = -1; let dots = 0; let code = 0; for (let i = 0; i <= path.length; ++i) { - if (i < path.length) code = path.charCodeAt(i); - else if (isPathSeparator(code)) break; - else code = CHAR_FORWARD_SLASH; + if (i < path.length) + code = path.charCodeAt(i); + else if (isPathSeparator(code)) + break; + else + code = CHAR_FORWARD_SLASH; if (isPathSeparator(code)) { if (lastSlash === i - 1 || dots === 1) { // NOOP } else if (dots === 2) { - if ( - res.length < 2 || - lastSegmentLength !== 2 || + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || - res.charCodeAt(res.length - 2) !== CHAR_DOT - ) { + res.charCodeAt(res.length - 2) !== CHAR_DOT) { if (res.length > 2) { const lastSlashIndex = res.lastIndexOf(separator); if (lastSlashIndex === -1) { - res = ""; + res = ''; lastSegmentLength = 0; } else { res = res.slice(0, lastSlashIndex); - lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + lastSegmentLength = + res.length - 1 - res.lastIndexOf(separator); } lastSlash = i; dots = 0; continue; } else if (res.length !== 0) { - res = ""; + res = ''; lastSegmentLength = 0; lastSlash = i; dots = 0; @@ -54,12 +56,14 @@ function normalizeString( } } if (allowAboveRoot) { - res += res.length > 0 ? `${separator}..` : ".."; + res += res.length > 0 ? `${separator}..` : '..'; lastSegmentLength = 2; } } else { - if (res.length > 0) res += `${separator}${path.slice(lastSlash + 1, i)}`; - else res = path.slice(lastSlash + 1, i); + if (res.length > 0) + res += `${separator}${path.slice(lastSlash + 1, i)}`; + else + res = path.slice(lastSlash + 1, i); lastSegmentLength = i - lastSlash - 1; } lastSlash = i; @@ -73,8 +77,8 @@ function normalizeString( return res; } -function formatExt(ext: string) { - return ext ? `${ext[0] === "." ? "" : "."}${ext}` : ""; +function formatExt(ext : string) { + return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : ''; } /** @@ -97,10 +101,11 @@ type PathObject = { ext?: string; }; -function _format(sep: string, pathObject: PathObject) { - validateObject(pathObject, "pathObject", {}); +function _format(sep : string, pathObject : PathObject) { + validateObject(pathObject, 'pathObject', {}); const dir = pathObject.dir || pathObject.root; - const base = pathObject.base || `${pathObject.name || ""}${formatExt(pathObject.ext!)}`; + const base = pathObject.base || + `${pathObject.name || ''}${formatExt(pathObject.ext!)}`; if (!dir) { return base; } @@ -110,53 +115,53 @@ function _format(sep: string, pathObject: PathObject) { // We currently do not implement the path.win32 subset. const win32 = { resolve(..._: [string[], string]) { - throw new Error("path.win32.resolve() is not implemented."); + throw new Error('path.win32.resolve() is not implemented.'); }, - normalize(_: string) { - throw new Error("path.win32.normalize() is not implemented."); + normalize(_ : string) { + throw new Error('path.win32.normalize() is not implemented.'); }, - isAbsolute(_: string) { - throw new Error("path.win32.isAbsolute() is not implemented."); + isAbsolute(_ : string) { + throw new Error('path.win32.isAbsolute() is not implemented.'); }, - join(..._: string[]) { - throw new Error("path.win32.join() is not implemented."); + join(..._ : string[]) { + throw new Error('path.win32.join() is not implemented.'); }, - relative(_0: string, _1: string) { - throw new Error("path.win32.relative() is not implemented."); + relative(_0 : string, _1 : string) { + throw new Error('path.win32.relative() is not implemented.'); }, - toNamespacedPath(_: string) { - throw new Error("path.win32.toNamedspacedPath() is not implemented."); + toNamespacedPath(_ : string) { + throw new Error('path.win32.toNamedspacedPath() is not implemented.'); }, - dirname(_: string) { - throw new Error("path.win32.dirname() is not implemented."); + dirname(_ : string) { + throw new Error('path.win32.dirname() is not implemented.'); }, - basename(_0: string, _1?: string) { - throw new Error("path.win32.basename() is not implemented."); - }, + basename(_0 : string, _1? : string) { + throw new Error('path.win32.basename() is not implemented.'); +}, - extname(_: string) { - throw new Error("path.win32.extname() is not implemented."); - }, +extname(_ : string) { + throw new Error('path.win32.extname() is not implemented.'); +}, - format(_: PathObject) { - throw new Error("path.win32.format() is not implemented."); - }, +format(_ : PathObject) { + throw new Error('path.win32.format() is not implemented.'); +}, - parse(_: string) { - throw new Error("path.win32.parse() is not implemented."); - }, +parse(_: string) { + throw new Error('path.win32.parse() is not implemented.'); +}, - sep: "\\", - delimiter: ";", - win32: null as Object | null, - posix: null as Object | null, +sep: '\\', + delimiter: ';', + win32: null as Object|null, + posix: null as Object|null, }; const posix = { @@ -166,13 +171,13 @@ const posix = { * @returns {string} */ resolve(...args: string[]) { - let resolvedPath = ""; + let resolvedPath = ''; let resolvedAbsolute = false; for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { - const path = i >= 0 ? args[i] : "/"; + const path = i >= 0 ? args[i] : '/'; - validateString(path, "path"); + validateString(path, 'path'); // Skip empty entries if (path!.length === 0) { @@ -187,34 +192,38 @@ const posix = { // handle relative paths to be safe (might happen when process.cwd() fails) // Normalize the path - resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator); + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', + isPosixPathSeparator); if (resolvedAbsolute) { return `/${resolvedPath}`; } - return resolvedPath.length > 0 ? resolvedPath : "."; + return resolvedPath.length > 0 ? resolvedPath : '.'; }, /** * @param {string} path * @returns {string} */ - normalize(path: string) { - validateString(path, "path"); + normalize(path : string) { + validateString(path, 'path'); - if (path.length === 0) return "."; + if (path.length === 0) + return '.'; const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH; // Normalize the path - path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator); + path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator); if (path.length === 0) { - if (isAbsolute) return "/"; - return trailingSeparator ? "./" : "."; + if (isAbsolute) + return '/'; + return trailingSeparator ? './' : '.'; } - if (trailingSeparator) path += "/"; + if (trailingSeparator) + path += '/'; return isAbsolute ? `/${path}` : path; }, @@ -223,8 +232,8 @@ const posix = { * @param {string} path * @returns {boolean} */ - isAbsolute(path: string) { - validateString(path, "path"); + isAbsolute(path : string) { + validateString(path, 'path'); return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH; }, @@ -232,18 +241,22 @@ const posix = { * @param {...string} args * @returns {string} */ - join(...args: string[]) { - if (args.length === 0) return "."; + join(...args : string[]) { + if (args.length === 0) + return '.'; let joined; for (let i = 0; i < args.length; ++i) { const arg = args[i]; - validateString(arg, "path"); + validateString(arg, 'path'); if (arg!.length > 0) { - if (joined === undefined) joined = arg; - else joined += `/${arg}`; + if (joined === undefined) + joined = arg; + else + joined += `/${arg}`; } } - if (joined === undefined) return "."; + if (joined === undefined) + return '.'; return posix.normalize(joined); }, @@ -252,17 +265,19 @@ const posix = { * @param {string} to * @returns {string} */ - relative(from: string, to: string) { - validateString(from, "from"); - validateString(to, "to"); + relative(from: string, to : string) { + validateString(from, 'from'); + validateString(to, 'to'); - if (from === to) return ""; + if (from === to) + return ''; // Trim leading forward slashes. from = posix.resolve(from); to = posix.resolve(to); - if (from === to) return ""; + if (from === to) + return ''; const fromStart = 1; const fromEnd = from.length; @@ -271,13 +286,15 @@ const posix = { const toLen = to.length - toStart; // Compare paths to find the longest common path from root - const length = fromLen < toLen ? fromLen : toLen; + const length = (fromLen < toLen ? fromLen : toLen); let lastCommonSep = -1; let i = 0; for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i); - if (fromCode !== to.charCodeAt(toStart + i)) break; - else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i; + if (fromCode !== to.charCodeAt(toStart + i)) + break; + else if (fromCode === CHAR_FORWARD_SLASH) + lastCommonSep = i; } if (i === length) { if (toLen > length) { @@ -304,12 +321,12 @@ const posix = { } } - let out = ""; + let out = ''; // Generate the relative path based on the path difference between `to` // and `from`. for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { - out += out.length === 0 ? ".." : "/.."; + out += out.length === 0 ? '..' : '/..'; } } @@ -322,7 +339,7 @@ const posix = { * @param {string} path * @returns {string} */ - toNamespacedPath(path: string) { + toNamespacedPath(path : string) { // Non-op on posix systems return path; }, @@ -331,9 +348,10 @@ const posix = { * @param {string} path * @returns {string} */ - dirname(path: string) { - validateString(path, "path"); - if (path.length === 0) return "."; + dirname(path : string) { + validateString(path, 'path'); + if (path.length === 0) + return '.'; const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH; let end = -1; let matchedSlash = true; @@ -349,8 +367,10 @@ const posix = { } } - if (end === -1) return hasRoot ? "/" : "."; - if (hasRoot && end === 1) return "//"; + if (end === -1) + return hasRoot ? '/' : '.'; + if (hasRoot && end === 1) + return '//'; return path.slice(0, end); }, @@ -359,131 +379,138 @@ const posix = { * @param {string} [suffix] * @returns {string} */ - basename(path: string, suffix?: string) { - if (suffix !== undefined) validateString(suffix, "ext"); - validateString(path, "path"); - - let start = 0; - let end = -1; - let matchedSlash = true; - - if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { - if (suffix === path) return ""; - let extIdx = suffix.length - 1; - let firstNonSlashEnd = -1; - for (let i = path.length - 1; i >= 0; --i) { - const code = path.charCodeAt(i); - if (code === CHAR_FORWARD_SLASH) { - // If we reached a path separator that was not part of a set of path - // separators at the end of the string, stop now - if (!matchedSlash) { - start = i + 1; - break; - } - } else { - if (firstNonSlashEnd === -1) { - // We saw the first non-path separator, remember this index in case - // we need it if the extension ends up not matching - matchedSlash = false; - firstNonSlashEnd = i + 1; - } - if (extIdx >= 0) { - // Try to match the explicit extension - if (code === suffix.charCodeAt(extIdx)) { - if (--extIdx === -1) { - // We matched the extension, so mark this as the end of our path - // component - end = i; - } - } else { - // Extension does not match, so our result is the entire path - // component - extIdx = -1; - end = firstNonSlashEnd; - } - } - } - } - - if (start === end) end = firstNonSlashEnd; - else if (end === -1) end = path.length; - return path.slice(start, end); - } + basename(path : string, suffix? : string) { + if (suffix !== undefined) + validateString(suffix, 'ext'); + validateString(path, 'path'); + + let start = 0; + let end = -1; + let matchedSlash = true; + + if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { + if (suffix === path) + return ''; + let extIdx = suffix.length - 1; + let firstNonSlashEnd = -1; for (let i = path.length - 1; i >= 0; --i) { - if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { // If we reached a path separator that was not part of a set of path // separators at the end of the string, stop now if (!matchedSlash) { start = i + 1; break; } - } else if (end === -1) { - // We saw the first non-path separator, mark this as the end of our - // path component - matchedSlash = false; - end = i + 1; + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === suffix.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } } } - if (end === -1) return ""; + if (start === end) + end = firstNonSlashEnd; + else if (end === -1) + end = path.length; return path.slice(start, end); - }, - - /** - * @param {string} path - * @returns {string} - */ - extname(path: string) { - validateString(path, "path"); - let startDot = -1; - let startPart = 0; - let end = -1; - let matchedSlash = true; - // Track the state of characters (if any) we see before our first dot and - // after any path separator we find - let preDotState = 0; - for (let i = path.length - 1; i >= 0; --i) { - const code = path.charCodeAt(i); - if (code === CHAR_FORWARD_SLASH) { - // If we reached a path separator that was not part of a set of path - // separators at the end of the string, stop now - if (!matchedSlash) { - startPart = i + 1; - break; - } - continue; - } - if (end === -1) { - // We saw the first non-path separator, mark this as the end of our - // extension - matchedSlash = false; - end = i + 1; - } - if (code === CHAR_DOT) { - // If this is our first dot, mark it as the start of our extension - if (startDot === -1) startDot = i; - else if (preDotState !== 1) preDotState = 1; - } else if (startDot !== -1) { - // We saw a non-dot and non-path separator before our dot, so we should - // have a good chance at having a non-empty extension - preDotState = -1; + } + for (let i = path.length - 1; i >= 0; --i) { + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; } + } - if ( - startDot === -1 || - end === -1 || - // We saw a non-dot character immediately before the dot - preDotState === 0 || - // The (right-most) trimmed path component is exactly '..' - (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) - ) { - return ""; + if (end === -1) + return ''; + return path.slice(start, end); +}, + +/** + * @param {string} path + * @returns {string} + */ +extname(path : string) { + validateString(path, 'path'); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + for (let i = path.length - 1; i >= 0; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; } - return path.slice(startDot, end); - }, + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) + startDot = i; + else if (preDotState !== 1) + preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if (startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && + startDot === end - 1 && + startDot === startPart + 1)) { + return ''; + } + return path.slice(startDot, end); +}, - format: _format.bind(null, "/"), +format: _format.bind(null, '/'), /** * @param {string} path @@ -495,89 +522,95 @@ const posix = { * ext: string; * }} */ - parse(path: string): PathObject { - validateString(path, "path"); - - const ret = { root: "", dir: "", base: "", ext: "", name: "" }; - if (path.length === 0) return ret; - const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; - let start; - if (isAbsolute) { - ret.root = "/"; - start = 1; - } else { - start = 0; - } - let startDot = -1; - let startPart = 0; - let end = -1; - let matchedSlash = true; - let i = path.length - 1; - - // Track the state of characters (if any) we see before our first dot and - // after any path separator we find - let preDotState = 0; + parse(path: string) : PathObject { + validateString(path, 'path'); - // Get non-dir info - for (; i >= start; --i) { - const code = path.charCodeAt(i); - if (code === CHAR_FORWARD_SLASH) { - // If we reached a path separator that was not part of a set of path - // separators at the end of the string, stop now - if (!matchedSlash) { - startPart = i + 1; - break; - } - continue; - } - if (end === -1) { - // We saw the first non-path separator, mark this as the end of our - // extension - matchedSlash = false; - end = i + 1; - } - if (code === CHAR_DOT) { - // If this is our first dot, mark it as the start of our extension - if (startDot === -1) startDot = i; - else if (preDotState !== 1) preDotState = 1; - } else if (startDot !== -1) { - // We saw a non-dot and non-path separator before our dot, so we should - // have a good chance at having a non-empty extension - preDotState = -1; + const ret = { root: '', dir: '', base: '', ext: '', name: '' }; + if (path.length === 0) + return ret; + const isAbsolute = + path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let start; + if (isAbsolute) { + ret.root = '/'; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Get non-dir info + for (; i >= start; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; } + continue; } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) + startDot = i; + else if (preDotState !== 1) + preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } - if (end !== -1) { - const start = startPart === 0 && isAbsolute ? 1 : startPart; - if ( - startDot === -1 || - // We saw a non-dot character immediately before the dot - preDotState === 0 || - // The (right-most) trimmed path component is exactly '..' - (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) - ) { - ret.base = ret.name = path.slice(start, end); - } else { - ret.name = path.slice(start, startDot); - ret.base = path.slice(start, end); - ret.ext = path.slice(startDot, end); - } + if (end !== -1) { + const start = startPart === 0 && isAbsolute ? 1 : startPart; + if (startDot === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && + startDot === end - 1 && + startDot === startPart + 1)) { + ret.base = ret.name = path.slice(start, end); + } else { + ret.name = path.slice(start, startDot); + ret.base = path.slice(start, end); + ret.ext = path.slice(startDot, end); } + } - if (startPart > 0) ret.dir = path.slice(0, startPart - 1); - else if (isAbsolute) ret.dir = "/"; + if (startPart > 0) + ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) + ret.dir = '/'; - return ret; - }, + return ret; +}, - sep: "/", - delimiter: ":", - win32: null as Object | null, - posix: null as Object | null, +sep: '/', + delimiter: ':', + win32: null as Object|null, + posix: null as Object|null, }; posix.win32 = win32.win32 = win32; posix.posix = win32.posix = posix; export default posix; -export { posix, win32 }; +export { posix, win32 }; \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_stringdecoder.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_stringdecoder.ts index 0ed5a1db5..63474c628 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_stringdecoder.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_stringdecoder.ts @@ -1,8 +1,13 @@ -import { Buffer, isEncoding } from "./internal_buffer"; -import { normalizeEncoding } from "./internal_utils"; -import { ERR_INVALID_ARG_TYPE, ERR_INVALID_THIS, ERR_UNKNOWN_ENCODING } from "./internal_errors"; -import * as bufferUtil from "./buffer"; +import { Buffer, isEncoding } from './internal_buffer'; +import { normalizeEncoding } from './internal_utils'; +import { + ERR_INVALID_ARG_TYPE, + ERR_INVALID_THIS, + ERR_UNKNOWN_ENCODING, +} from './internal_errors'; + +import * as bufferUtil from './buffer'; const kIncompleteCharactersStart = 0; const kIncompleteCharactersEnd = 4; @@ -11,83 +16,81 @@ const kBufferedBytes = 5; const kEncoding = 6; const kSize = 7; -const encodings: Record = { - ascii: 0, - latin1: 1, - utf8: 2, - utf16le: 3, - base64: 4, - base64url: 5, - hex: 6, +const encodings : Record = { + ascii: 0, + latin1: 1, + utf8: 2, + utf16le: 3, + base64: 4, + base64url: 5, + hex: 6, }; -const kNativeDecoder = Symbol("kNativeDecoder"); +const kNativeDecoder = Symbol('kNativeDecoder'); export interface StringDecoder { - encoding: string; - readonly lastChar: Uint8Array; - readonly lastNeed: number; - readonly lastTotal: number; - new (encoding?: string): StringDecoder; - write(buf: ArrayBufferView | DataView | string): string; - end(buf?: ArrayBufferView | DataView | string): string; - text(buf: ArrayBufferView | DataView | string, offset?: number): string; - new (encoding?: string): StringDecoder; + encoding: string; + readonly lastChar: Uint8Array; + readonly lastNeed: number; + readonly lastTotal: number; + new (encoding? : string): StringDecoder; + write(buf: ArrayBufferView|DataView|string): string; + end(buf?: ArrayBufferView|DataView|string): string; + text(buf: ArrayBufferView|DataView|string, offset?: number): string; + new (encoding?: string): StringDecoder; } interface InternalDecoder extends StringDecoder { - [kNativeDecoder]: Buffer; + [kNativeDecoder]: Buffer; } -export function StringDecoder(this: StringDecoder, encoding: string = "utf8") { - const normalizedEncoding = normalizeEncoding(encoding); - if (!isEncoding(normalizedEncoding)) { - throw new ERR_UNKNOWN_ENCODING(encoding); - } - (this as InternalDecoder)[kNativeDecoder] = Buffer.alloc(kSize); - (this as InternalDecoder)[kNativeDecoder][kEncoding] = encodings[normalizedEncoding!]!; - this.encoding = normalizedEncoding!; +export function StringDecoder(this: StringDecoder, encoding: string = 'utf8') { + const normalizedEncoding = normalizeEncoding(encoding); + if (!isEncoding(normalizedEncoding)) { + throw new ERR_UNKNOWN_ENCODING(encoding); + } + (this as InternalDecoder)[kNativeDecoder] = Buffer.alloc(kSize); + (this as InternalDecoder)[kNativeDecoder][kEncoding] = encodings[normalizedEncoding!]!; + this.encoding = normalizedEncoding!; } -function write(this: StringDecoder, buf: ArrayBufferView | DataView | string): string { - if ((this as InternalDecoder)[kNativeDecoder] === undefined) { - throw new ERR_INVALID_THIS("StringDecoder"); - } - if (typeof buf === "string") { - return buf; - } - if (!ArrayBuffer.isView(buf)) { - throw new ERR_INVALID_ARG_TYPE("buf", ["Buffer", "TypedArray", "DataView", "string"], buf); - } - const buffer = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength); - return bufferUtil.decode(buffer, (this as InternalDecoder)[kNativeDecoder]); +function write(this: StringDecoder, buf: ArrayBufferView|DataView|string): string { + if ((this as InternalDecoder)[kNativeDecoder] === undefined) { + throw new ERR_INVALID_THIS('StringDecoder'); + } + if (typeof buf === 'string') { + return buf; + } + if (!ArrayBuffer.isView(buf)) { + throw new ERR_INVALID_ARG_TYPE('buf', [ + 'Buffer', 'TypedArray', 'DataView', 'string' + ], buf); + } + const buffer = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength); + return bufferUtil.decode(buffer, (this as InternalDecoder)[kNativeDecoder]); } -function end(this: StringDecoder, buf?: ArrayBufferView | DataView | string): string { - if ((this as InternalDecoder)[kNativeDecoder] === undefined) { - throw new ERR_INVALID_THIS("StringDecoder"); - } - let ret = ""; - if (buf !== undefined) { - ret = this.write(buf); - } - if ((this as InternalDecoder)[kNativeDecoder][kBufferedBytes]! > 0) { - ret += bufferUtil.flush((this as InternalDecoder)[kNativeDecoder]); - } - return ret; +function end(this: StringDecoder, buf?: ArrayBufferView|DataView|string): string { + if ((this as InternalDecoder)[kNativeDecoder] === undefined) { + throw new ERR_INVALID_THIS('StringDecoder'); + } + let ret = ''; + if (buf !== undefined) { + ret = this.write(buf); + } + if ((this as InternalDecoder)[kNativeDecoder][kBufferedBytes]! > 0) { + ret += bufferUtil.flush((this as InternalDecoder)[kNativeDecoder]); + } + return ret; } -function text( - this: StringDecoder, - buf: ArrayBufferView | DataView | string, - offset?: number -): string { - if ((this as InternalDecoder)[kNativeDecoder] === undefined) { - throw new ERR_INVALID_THIS("StringDecoder"); - } - (this as InternalDecoder)[kNativeDecoder][kMissingBytes] = 0; - (this as InternalDecoder)[kNativeDecoder][kBufferedBytes] = 0; - return this.write((buf as any).slice(offset)); +function text(this: StringDecoder, buf: ArrayBufferView|DataView|string, offset?: number) : string { + if ((this as InternalDecoder)[kNativeDecoder] === undefined) { + throw new ERR_INVALID_THIS('StringDecoder'); + } + (this as InternalDecoder)[kNativeDecoder][kMissingBytes] = 0; + (this as InternalDecoder)[kNativeDecoder][kBufferedBytes] = 0; + return this.write((buf as any).slice(offset)); } StringDecoder.prototype.write = write; @@ -95,41 +98,37 @@ StringDecoder.prototype.end = end; StringDecoder.prototype.text = text; Object.defineProperties(StringDecoder.prototype, { - lastChar: { - enumerable: true, - get(this: StringDecoder): Buffer { - if ((this as InternalDecoder)[kNativeDecoder] === undefined) { - throw new ERR_INVALID_THIS("StringDecoder"); - } - return (this as InternalDecoder)[kNativeDecoder].subarray( - kIncompleteCharactersStart, - kIncompleteCharactersEnd - ) as Buffer; - }, + lastChar: { + enumerable: true, + get(this: StringDecoder) : Buffer { + if ((this as InternalDecoder)[kNativeDecoder] === undefined) { + throw new ERR_INVALID_THIS('StringDecoder'); + } + return (this as InternalDecoder)[kNativeDecoder].subarray( + kIncompleteCharactersStart, kIncompleteCharactersEnd) as Buffer; }, - lastNeed: { - enumerable: true, - get(this: StringDecoder): number { - if ((this as InternalDecoder)[kNativeDecoder] === undefined) { - throw new ERR_INVALID_THIS("StringDecoder"); - } - return (this as InternalDecoder)[kNativeDecoder][kMissingBytes]!; - }, + }, + lastNeed: { + enumerable: true, + get(this: StringDecoder) : number { + if ((this as InternalDecoder)[kNativeDecoder] === undefined) { + throw new ERR_INVALID_THIS('StringDecoder'); + } + return (this as InternalDecoder)[kNativeDecoder][kMissingBytes]!; }, - lastTotal: { - enumerable: true, - get(this: StringDecoder): number { - if ((this as InternalDecoder)[kNativeDecoder] === undefined) { - throw new ERR_INVALID_THIS("StringDecoder"); - } - return ( - (this as InternalDecoder)[kNativeDecoder][kBufferedBytes]! + - (this as InternalDecoder)[kNativeDecoder][kMissingBytes]! - ); - }, + }, + lastTotal: { + enumerable: true, + get(this: StringDecoder) : number { + if ((this as InternalDecoder)[kNativeDecoder] === undefined) { + throw new ERR_INVALID_THIS('StringDecoder'); + } + return (this as InternalDecoder)[kNativeDecoder][kBufferedBytes]! + + (this as InternalDecoder)[kNativeDecoder][kMissingBytes]!; }, + }, }); export default { - StringDecoder, + StringDecoder }; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_types.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_types.ts index 5fd751258..5fb614dff 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_types.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_types.ts @@ -1,3 +1,4 @@ + import * as internal from "./util"; export function isCryptoKey(value: unknown): boolean { @@ -93,4 +94,4 @@ export default { isUint16Array, isUint32Array, // TODO(soon): isExternal -}; +}; \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_utils.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_utils.ts index 6cf8b3848..a75b67790 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_utils.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/internal_utils.ts @@ -1,10 +1,14 @@ -export function normalizeEncoding(enc?: string): string | undefined { - if (enc == null || enc === "utf8" || enc === "utf-8" || enc === "UTF8" || enc === "UTF-8") - return "utf8"; + +export function normalizeEncoding(enc?: string) : string | undefined { + if (enc == null || + enc === "utf8" || + enc === "utf-8" || + enc === "UTF8" || + enc === "UTF-8") return "utf8"; return slowCases(enc); } -export function slowCases(enc: string): string | undefined { +export function slowCases(enc: string) : string | undefined { switch (enc.length) { case 4: if (enc === "UTF8") return "utf8"; @@ -14,7 +18,10 @@ export function slowCases(enc: string): string | undefined { if (enc === "ucs2") return "utf16le"; break; case 3: - if (enc === "hex" || enc === "HEX" || `${enc}`.toLowerCase() === "hex") { + if ( + enc === "hex" || enc === "HEX" || + `${enc}`.toLowerCase() === "hex" + ) { return "hex"; } break; @@ -39,19 +46,24 @@ export function slowCases(enc: string): string | undefined { if (enc === "latin1" || enc === "binary") return "latin1"; break; case 7: - if (enc === "utf16le" || enc === "UTF16LE" || `${enc}`.toLowerCase() === "utf16le") { + if ( + enc === "utf16le" || enc === "UTF16LE" || + `${enc}`.toLowerCase() === "utf16le" + ) { return "utf16le"; } break; case 8: - if (enc === "utf-16le" || enc === "UTF-16LE" || `${enc}`.toLowerCase() === "utf-16le") { + if ( + enc === "utf-16le" || enc === "UTF-16LE" || + `${enc}`.toLowerCase() === "utf-16le" + ) { return "utf16le"; } break; case 9: if ( - enc === "base64url" || - enc === "BASE64URL" || + enc === "base64url" || enc === "BASE64URL" || `${enc}`.toLowerCase() === "base64url" ) { return "base64url"; @@ -63,7 +75,7 @@ export function slowCases(enc: string): string | undefined { return undefined; } -export function spliceOne(list: (string | undefined)[], index: number) { +export function spliceOne(list: (string|undefined)[], index: number) { for (; index + 1 < list.length; index++) list[index] = list[index + 1]; list.pop(); } @@ -88,21 +100,20 @@ export function isArrayIndex(value: unknown): value is number | string { } const length = value.length; if (length === 0) { - return (isNumericLookup[value] = false); + return isNumericLookup[value] = false; } let ch = 0; let i = 0; for (; i < length; ++i) { ch = value.charCodeAt(i); if ( - (i === 0 && ch === 0x30 && length > 1) /* must not start with 0 */ || - ch < 0x30 /* 0 */ || - ch > 0x39 /* 9 */ + i === 0 && ch === 0x30 && length > 1 /* must not start with 0 */ || + ch < 0x30 /* 0 */ || ch > 0x39 /* 9 */ ) { - return (isNumericLookup[value] = false); + return isNumericLookup[value] = false; } } - return (isNumericLookup[value] = true); + return isNumericLookup[value] = true; } default: return false; @@ -112,9 +123,12 @@ export function isArrayIndex(value: unknown): value is number | string { export function getOwnNonIndexProperties( // deno-lint-ignore ban-types obj: object, - filter: number + filter: number, ): (string | symbol)[] { - let allProperties = [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)]; + let allProperties = [ + ...Object.getOwnPropertyNames(obj), + ...Object.getOwnPropertySymbols(obj), + ]; if (Array.isArray(obj)) { allProperties = allProperties.filter((k) => !isArrayIndex(k)); @@ -158,10 +172,11 @@ export function createDeferredPromise() { const promise = new Promise((res, rej) => { resolve = res; reject = rej; - }); + }) return { promise, resolve, reject, }; } + diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/process.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/process.ts index 522a74ecd..d72466f2c 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/process.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/process.ts @@ -1,12 +1,14 @@ -import { validateObject } from "./validators"; +import { + validateObject, +} from './validators'; -import { ERR_INVALID_ARG_VALUE } from "./internal_errors"; +import { + ERR_INVALID_ARG_VALUE, +} from './internal_errors' export function nextTick(cb: Function, ...args: unknown[]) { - queueMicrotask(() => { - cb(...args); - }); -} + queueMicrotask(() => { cb(...args); }); +}; // Note that there is no process-level environment in workers so the process.env // object is initially empty. This is different from Node.js where process.env @@ -14,67 +16,50 @@ export function nextTick(cb: Function, ...args: unknown[]) { // for the worker are accessible from the env argument passed into the fetch // handler and have no impact here. -export const env = new Proxy( - {}, - { - // Per Node.js rules. process.env values must be coerced to strings. - // When defined using defineProperty, the property descriptor must be writable, - // configurable, and enumerable using just a falsy check. Getters and setters - // are not permitted. - set(obj: object, prop: PropertyKey, value: any) { - return Reflect.set(obj, prop, `${value}`); - }, - defineProperty(obj: object, prop: PropertyKey, descriptor: PropertyDescriptor) { - validateObject(descriptor, "descriptor", {}); - if (Reflect.has(descriptor, "get") || Reflect.has(descriptor, "set")) { - throw new ERR_INVALID_ARG_VALUE( - "descriptor", - descriptor, - "process.env value must not have getter/setter" - ); - } - if (!descriptor.configurable) { - throw new ERR_INVALID_ARG_VALUE( - "descriptor.configurable", - descriptor, - "process.env value must be configurable" - ); - } - if (!descriptor.enumerable) { - throw new ERR_INVALID_ARG_VALUE( - "descriptor.enumerable", - descriptor, - "process.env value must be enumerable" - ); - } - if (!descriptor.writable) { - throw new ERR_INVALID_ARG_VALUE( - "descriptor.writable", - descriptor, - "process.env value must be writable" - ); - } - if (Reflect.has(descriptor, "value")) { - Reflect.set(descriptor, "value", `${descriptor.value}`); - } else { - throw new ERR_INVALID_ARG_VALUE( - "descriptor.value", - descriptor, - "process.env value must be specified explicitly" - ); - } - return Reflect.defineProperty(obj, prop, descriptor); - }, +export const env = new Proxy({}, { + // Per Node.js rules. process.env values must be coerced to strings. + // When defined using defineProperty, the property descriptor must be writable, + // configurable, and enumerable using just a falsy check. Getters and setters + // are not permitted. + set(obj: object, prop: PropertyKey, value: any) { + return Reflect.set(obj, prop, `${value}`); + }, + defineProperty(obj: object, prop: PropertyKey, descriptor: PropertyDescriptor) { + validateObject(descriptor, 'descriptor', {}); + if (Reflect.has(descriptor, 'get') || Reflect.has(descriptor, 'set')) { + throw new ERR_INVALID_ARG_VALUE('descriptor', descriptor, + 'process.env value must not have getter/setter'); + } + if (!descriptor.configurable) { + throw new ERR_INVALID_ARG_VALUE('descriptor.configurable', descriptor, + 'process.env value must be configurable') + } + if (!descriptor.enumerable) { + throw new ERR_INVALID_ARG_VALUE('descriptor.enumerable', descriptor, + 'process.env value must be enumerable') } -); + if (!descriptor.writable) { + throw new ERR_INVALID_ARG_VALUE('descriptor.writable', descriptor, + 'process.env value must be writable') + } + if (Reflect.has(descriptor, 'value')) { + Reflect.set(descriptor, 'value', `${descriptor.value}`); + } else { + throw new ERR_INVALID_ARG_VALUE('descriptor.value', descriptor, + 'process.env value must be specified explicitly'); + } + return Reflect.defineProperty(obj, prop, descriptor); + } +}); export const argv = []; -export const platform = "wasm"; +export const platform = 'wasm'; + export default { - nextTick, - env, - argv, - platform, + nextTick, + env, + argv, + platform, }; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_adapters.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_adapters.js index 819808333..ad3aadfed 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_adapters.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_adapters.js @@ -1,35 +1,49 @@ /* eslint-disable */ -import { Readable } from "./streams_readable"; +import { + Readable, +} from './streams_readable'; import { TextEncoder, TextDecoder } from "@sinonjs/text-encoding"; -import { Writable } from "./streams_writable"; +import { + Writable, +} from './streams_writable'; -import { Duplex } from "./streams_duplex"; +import { + Duplex, +} from './streams_duplex'; import { - destroy, - eos as finished, - isDestroyed, - isReadable, - isWritable, - isWritableEnded, -} from "./streams_util"; + destroy, + eos as finished, + isDestroyed, + isReadable, + isWritable, + isWritableEnded, +} from './streams_util'; -import { Buffer } from "./internal_buffer"; +import { + Buffer, +} from './internal_buffer'; import { - ERR_INVALID_ARG_TYPE, - ERR_INVALID_ARG_VALUE, - ERR_STREAM_PREMATURE_CLOSE, - AbortError, -} from "./internal_errors"; + ERR_INVALID_ARG_TYPE, + ERR_INVALID_ARG_VALUE, + ERR_STREAM_PREMATURE_CLOSE, + AbortError, +} from './internal_errors'; -import { createDeferredPromise, normalizeEncoding } from "./internal_utils"; +import { + createDeferredPromise, + normalizeEncoding, +} from './internal_utils'; -import { validateBoolean, validateObject } from "./validators"; +import { + validateBoolean, + validateObject, +} from './validators'; -import * as process from "./process"; +import * as process from './process'; const encoder = new TextEncoder(); @@ -38,105 +52,107 @@ const encoder = new TextEncoder(); * @returns {WritableStream} */ export function newWritableStreamFromStreamWritable(streamWritable) { - // Not using the internal/streams/utils isWritableNodeStream utility - // here because it will return false if streamWritable is a Duplex - // whose writable option is false. For a Duplex that is not writable, - // we want it to pass this check but return a closed WritableStream. - // We check if the given stream is a stream.Writable or http.OutgoingMessage - const checkIfWritableOrOutgoingMessage = - streamWritable && - typeof streamWritable?.write === "function" && - typeof streamWritable?.on === "function"; - if (!checkIfWritableOrOutgoingMessage) { - throw new ERR_INVALID_ARG_TYPE("streamWritable", "stream.Writable", streamWritable); - } + // Not using the internal/streams/utils isWritableNodeStream utility + // here because it will return false if streamWritable is a Duplex + // whose writable option is false. For a Duplex that is not writable, + // we want it to pass this check but return a closed WritableStream. + // We check if the given stream is a stream.Writable or http.OutgoingMessage + const checkIfWritableOrOutgoingMessage = + streamWritable && + typeof streamWritable?.write === 'function' && + typeof streamWritable?.on === 'function'; + if (!checkIfWritableOrOutgoingMessage) { + throw new ERR_INVALID_ARG_TYPE( + 'streamWritable', + 'stream.Writable', + streamWritable, + ); + } - if (isDestroyed(streamWritable) || !isWritable(streamWritable)) { - const writable = new WritableStream(); - writable.close(); - return writable; + if (isDestroyed(streamWritable) || !isWritable(streamWritable)) { + const writable = new WritableStream(); + writable.close(); + return writable; + } + + const highWaterMark = streamWritable.writableHighWaterMark; + const strategy = + streamWritable.writableObjectMode ? + new CountQueuingStrategy({ highWaterMark }) : + { highWaterMark }; + + let controller; + let backpressurePromise; + let closed; + + function onDrain() { + if (backpressurePromise !== undefined) + backpressurePromise.resolve(); + } + + const cleanup = finished(streamWritable, (error) => { + if (error?.code === 'ERR_STREAM_PREMATURE_CLOSE') { + const err = new AbortError(undefined, { cause: error }); + error = err; } - const highWaterMark = streamWritable.writableHighWaterMark; - const strategy = streamWritable.writableObjectMode - ? new CountQueuingStrategy({ highWaterMark }) - : { highWaterMark }; - - let controller; - let backpressurePromise; - let closed; - - function onDrain() { - if (backpressurePromise !== undefined) backpressurePromise.resolve(); + cleanup(); + // This is a protection against non-standard, legacy streams + // that happen to emit an error event again after finished is called. + streamWritable.on('error', () => {}); + if (error != null) { + if (backpressurePromise !== undefined) + backpressurePromise.reject(error); + // If closed is not undefined, the error is happening + // after the WritableStream close has already started. + // We need to reject it here. + if (closed !== undefined) { + closed.reject(error); + closed = undefined; + } + controller.error(error); + controller = undefined; + return; } - const cleanup = finished(streamWritable, (error) => { - if (error?.code === "ERR_STREAM_PREMATURE_CLOSE") { - const err = new AbortError(undefined, { cause: error }); - error = err; - } - - cleanup(); - // This is a protection against non-standard, legacy streams - // that happen to emit an error event again after finished is called. - streamWritable.on("error", () => {}); - if (error != null) { - if (backpressurePromise !== undefined) backpressurePromise.reject(error); - // If closed is not undefined, the error is happening - // after the WritableStream close has already started. - // We need to reject it here. - if (closed !== undefined) { - closed.reject(error); - closed = undefined; - } - controller.error(error); - controller = undefined; - return; - } - - if (closed !== undefined) { - closed.resolve(); - closed = undefined; - return; - } - controller.error(new AbortError()); - controller = undefined; - }); - - streamWritable.on("drain", onDrain); - - return new WritableStream( - { - start(c) { - controller = c; - }, - - async write(chunk) { - if (streamWritable.writableNeedDrain || !streamWritable.write(chunk)) { - backpressurePromise = createDeferredPromise(); - return backpressurePromise.promise.finally(() => { - backpressurePromise = undefined; - }); - } - }, - - abort(reason) { - destroy(streamWritable, reason); - }, - - close() { - if (closed === undefined && !isWritableEnded(streamWritable)) { - closed = createDeferredPromise(); - streamWritable.end(); - return closed.promise; - } - - controller = undefined; - return Promise.resolve(); - }, - }, - strategy - ); + if (closed !== undefined) { + closed.resolve(); + closed = undefined; + return; + } + controller.error(new AbortError()); + controller = undefined; + }); + + streamWritable.on('drain', onDrain); + + return new WritableStream({ + start(c) { controller = c; }, + + async write(chunk) { + if (streamWritable.writableNeedDrain || !streamWritable.write(chunk)) { + backpressurePromise = createDeferredPromise(); + return backpressurePromise.promise.finally(() => { + backpressurePromise = undefined; + }); + } + }, + + abort(reason) { + destroy(streamWritable, reason); + }, + + close() { + if (closed === undefined && !isWritableEnded(streamWritable)) { + closed = createDeferredPromise(); + streamWritable.end(); + return closed.promise; + } + + controller = undefined; + return Promise.resolve(); + }, + }, strategy); } /** @@ -150,134 +166,146 @@ export function newWritableStreamFromStreamWritable(streamWritable) { * @returns {Writable} */ export function newStreamWritableFromWritableStream(writableStream, options = {}) { - if (!(writableStream instanceof WritableStream)) { - throw new ERR_INVALID_ARG_TYPE("writableStream", "WritableStream", writableStream); - } + if (!(writableStream instanceof WritableStream)) { + throw new ERR_INVALID_ARG_TYPE( + 'writableStream', + 'WritableStream', + writableStream); + } + + validateObject(options, 'options'); + const { + highWaterMark, + decodeStrings = true, + objectMode = false, + signal, + } = options; + + validateBoolean(objectMode, 'options.objectMode'); + validateBoolean(decodeStrings, 'options.decodeStrings'); + + const writer = writableStream.getWriter(); + let closed = false; + + const writable = new Writable({ + highWaterMark, + objectMode, + decodeStrings, + signal, + + writev(chunks, callback) { + function done(error) { + error = error.filter((e) => e); + try { + callback(error.length === 0 ? undefined : error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => destroy(writable, error)); + } + } + + writer.ready.then(() => { + return Promise.all(chunks.map((data) => writer.write(data))) + .then(done, done); + }, + done); + }, + + write(chunk, encoding, callback) { + if (typeof chunk === 'string' && decodeStrings && !objectMode) { + const enc = normalizeEncoding(encoding); + + if (enc === 'utf8') { + chunk = encoder.encode(chunk); + } else { + chunk = Buffer.from(chunk, encoding); + chunk = new Uint8Array( + chunk.buffer, + chunk.byteOffset, + chunk.byteLength + ); + } + } - validateObject(options, "options"); - const { highWaterMark, decodeStrings = true, objectMode = false, signal } = options; - - validateBoolean(objectMode, "options.objectMode"); - validateBoolean(decodeStrings, "options.decodeStrings"); - - const writer = writableStream.getWriter(); - let closed = false; - - const writable = new Writable({ - highWaterMark, - objectMode, - decodeStrings, - signal, - - writev(chunks, callback) { - function done(error) { - error = error.filter((e) => e); - try { - callback(error.length === 0 ? undefined : error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => destroy(writable, error)); - } - } - - writer.ready.then(() => { - return Promise.all(chunks.map((data) => writer.write(data))).then(done, done); - }, done); - }, - - write(chunk, encoding, callback) { - if (typeof chunk === "string" && decodeStrings && !objectMode) { - const enc = normalizeEncoding(encoding); - - if (enc === "utf8") { - chunk = encoder.encode(chunk); - } else { - chunk = Buffer.from(chunk, encoding); - chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength); - } - } - - function done(error) { - try { - callback(error); - } catch (error) { - destroy(writable, error); - } - } - - writer.ready.then(() => { - return writer.write(chunk).then(done, done); - }, done); - }, - - destroy(error, callback) { - function done() { - try { - callback(error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => { - throw error; - }); - } - } - - if (!closed) { - if (error != null) { - writer.abort(error).then(done, done); - } else { - writer.close().then(done, done); - } - return; - } - - done(); - }, - - final(callback) { - function done(error) { - try { - callback(error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => destroy(writable, error)); - } - } - - if (!closed) { - writer.close().then(done, done); - } - }, - }); - - writer.closed.then( - () => { - // If the WritableStream closes before the stream.Writable has been - // ended, we signal an error on the stream.Writable. - closed = true; - if (!isWritableEnded(writable)) destroy(writable, new ERR_STREAM_PREMATURE_CLOSE()); - }, - (error) => { - // If the WritableStream errors before the stream.Writable has been - // destroyed, signal an error on the stream.Writable. - closed = true; - destroy(writable, error); + function done(error) { + try { + callback(error); + } catch (error) { + destroy(writable, error); } - ); + } + + writer.ready.then(() => { + return writer.write(chunk).then(done, done); + }, + done); + }, + + destroy(error, callback) { + function done() { + try { + callback(error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => { throw error; }); + } + } - return writable; + if (!closed) { + if (error != null) { + writer.abort(error).then(done, done); + } else { + writer.close().then(done, done); + } + return; + } + + done(); + }, + + final(callback) { + function done(error) { + try { + callback(error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => destroy(writable, error)); + } + } + + if (!closed) { + writer.close().then(done, done); + } + }, + }); + + writer.closed.then(() => { + // If the WritableStream closes before the stream.Writable has been + // ended, we signal an error on the stream.Writable. + closed = true; + if (!isWritableEnded(writable)) + destroy(writable, new ERR_STREAM_PREMATURE_CLOSE()); + }, + (error) => { + // If the WritableStream errors before the stream.Writable has been + // destroyed, signal an error on the stream.Writable. + closed = true; + destroy(writable, error); + }); + + return writable; } /** @@ -289,85 +317,85 @@ export function newStreamWritableFromWritableStream(writableStream, options = {} * @returns {ReadableStream} */ export function newReadableStreamFromStreamReadable(streamReadable, options = {}) { - // Not using the internal/streams/utils isReadableNodeStream utility - // here because it will return false if streamReadable is a Duplex - // whose readable option is false. For a Duplex that is not readable, - // we want it to pass this check but return a closed ReadableStream. - if (typeof streamReadable?._readableState !== "object") { - throw new ERR_INVALID_ARG_TYPE("streamReadable", "stream.Readable", streamReadable); - } + // Not using the internal/streams/utils isReadableNodeStream utility + // here because it will return false if streamReadable is a Duplex + // whose readable option is false. For a Duplex that is not readable, + // we want it to pass this check but return a closed ReadableStream. + if (typeof streamReadable?._readableState !== 'object') { + throw new ERR_INVALID_ARG_TYPE( + 'streamReadable', + 'stream.Readable', + streamReadable); + } + + if (isDestroyed(streamReadable) || !isReadable(streamReadable)) { + const readable = new ReadableStream(); + readable.cancel(); + return readable; + } - if (isDestroyed(streamReadable) || !isReadable(streamReadable)) { - const readable = new ReadableStream(); - readable.cancel(); - return readable; - } + const objectMode = streamReadable.readableObjectMode; + const highWaterMark = streamReadable.readableHighWaterMark; - const objectMode = streamReadable.readableObjectMode; - const highWaterMark = streamReadable.readableHighWaterMark; + const evaluateStrategyOrFallback = (strategy) => { + // If there is a strategy available, use it + if (strategy) + return strategy; - const evaluateStrategyOrFallback = (strategy) => { - // If there is a strategy available, use it - if (strategy) return strategy; + if (objectMode) { + // When running in objectMode explicitly but no strategy, we just fall + // back to CountQueuingStrategy + return new CountQueuingStrategy({ highWaterMark }); + } - if (objectMode) { - // When running in objectMode explicitly but no strategy, we just fall - // back to CountQueuingStrategy - return new CountQueuingStrategy({ highWaterMark }); - } + // When not running in objectMode explicitly, we just fall + // back to a minimal strategy that just specifies the highWaterMark + // and no size algorithm. Using a ByteLengthQueuingStrategy here + // is unnecessary. + return { highWaterMark }; + }; + + const strategy = evaluateStrategyOrFallback(options?.strategy); - // When not running in objectMode explicitly, we just fall - // back to a minimal strategy that just specifies the highWaterMark - // and no size algorithm. Using a ByteLengthQueuingStrategy here - // is unnecessary. - return { highWaterMark }; - }; + let controller; - const strategy = evaluateStrategyOrFallback(options?.strategy); + function onData(chunk) { + // Copy the Buffer to detach it from the pool. + if (Buffer.isBuffer(chunk) && !objectMode) + chunk = new Uint8Array(chunk); + controller.enqueue(chunk); + if (controller.desiredSize <= 0) + streamReadable.pause(); + } - let controller; + streamReadable.pause(); - function onData(chunk) { - // Copy the Buffer to detach it from the pool. - if (Buffer.isBuffer(chunk) && !objectMode) chunk = new Uint8Array(chunk); - controller.enqueue(chunk); - if (controller.desiredSize <= 0) streamReadable.pause(); + const cleanup = finished(streamReadable, (error) => { + if (error?.code === 'ERR_STREAM_PREMATURE_CLOSE') { + const err = new AbortError(undefined, { cause: error }); + error = err; } - streamReadable.pause(); + cleanup(); + // This is a protection against non-standard, legacy streams + // that happen to emit an error event again after finished is called. + streamReadable.on('error', () => {}); + if (error) + return controller.error(error); + controller.close(); + }); - const cleanup = finished(streamReadable, (error) => { - if (error?.code === "ERR_STREAM_PREMATURE_CLOSE") { - const err = new AbortError(undefined, { cause: error }); - error = err; - } + streamReadable.on('data', onData); - cleanup(); - // This is a protection against non-standard, legacy streams - // that happen to emit an error event again after finished is called. - streamReadable.on("error", () => {}); - if (error) return controller.error(error); - controller.close(); - }); - - streamReadable.on("data", onData); - - return new ReadableStream( - { - start(c) { - controller = c; - }, - - pull() { - streamReadable.resume(); - }, - - cancel(reason) { - destroy(streamReadable, reason); - }, - }, - strategy - ); + return new ReadableStream({ + start(c) { controller = c; }, + + pull() { streamReadable.resume(); }, + + cancel(reason) { + destroy(streamReadable, reason); + }, + }, strategy); } /** @@ -381,75 +409,77 @@ export function newReadableStreamFromStreamReadable(streamReadable, options = {} * @returns {Readable} */ export function newStreamReadableFromReadableStream(readableStream, options = {}) { - if (!(readableStream instanceof ReadableStream)) { - throw new ERR_INVALID_ARG_TYPE("readableStream", "ReadableStream", readableStream); - } - - validateObject(options, "options"); - const { highWaterMark, encoding, objectMode = false, signal } = options; - - if (encoding !== undefined && !Buffer.isEncoding(encoding)) - throw new ERR_INVALID_ARG_VALUE(encoding, "options.encoding"); - validateBoolean(objectMode, "options.objectMode"); - - const reader = readableStream.getReader(); - let closed = false; - - const readable = new Readable({ - objectMode, - highWaterMark, - encoding, - signal, - - read() { - reader.read().then( - (chunk) => { - if (chunk.done) { - // Value should always be undefined here. - readable.push(null); - } else { - readable.push(chunk.value); - } - }, - (error) => destroy(readable, error) - ); - }, - - destroy(error, callback) { - function done() { - try { - callback(error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => { - throw error; - }); - } - } - - if (!closed) { - reader.cancel(error).then(done, done); - return; - } - done(); - }, - }); - - reader.closed.then( - () => { - closed = true; - }, - (error) => { - closed = true; - destroy(readable, error); + if (!(readableStream instanceof ReadableStream)) { + throw new ERR_INVALID_ARG_TYPE( + 'readableStream', + 'ReadableStream', + readableStream); + } + + validateObject(options, 'options'); + const { + highWaterMark, + encoding, + objectMode = false, + signal, + } = options; + + if (encoding !== undefined && !Buffer.isEncoding(encoding)) + throw new ERR_INVALID_ARG_VALUE(encoding, 'options.encoding'); + validateBoolean(objectMode, 'options.objectMode'); + + const reader = readableStream.getReader(); + let closed = false; + + const readable = new Readable({ + objectMode, + highWaterMark, + encoding, + signal, + + read() { + reader.read().then((chunk) => { + if (chunk.done) { + // Value should always be undefined here. + readable.push(null); + } else { + readable.push(chunk.value); } - ); - - return readable; + }, + (error) => destroy(readable, error)); + }, + + destroy(error, callback) { + function done() { + try { + callback(error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => { throw error; }); + } + } + + if (!closed) { + reader.cancel(error).then(done, done); + return; + } + done(); + }, + }); + + reader.closed.then(() => { + closed = true; + }, + (error) => { + closed = true; + destroy(readable, error); + }); + + return readable; } /** @@ -463,37 +493,42 @@ export function newStreamReadableFromReadableStream(readableStream, options = {} * @returns {ReadableWritablePair} */ export function newReadableWritablePairFromDuplex(duplex) { - // Not using the internal/streams/utils isWritableNodeStream and - // isReadableNodeStream utilities here because they will return false - // if the duplex was created with writable or readable options set to - // false. Instead, we'll check the readable and writable state after - // and return closed WritableStream or closed ReadableStream as - // necessary. - if (typeof duplex?._writableState !== "object" || typeof duplex?._readableState !== "object") { - throw new ERR_INVALID_ARG_TYPE("duplex", "stream.Duplex", duplex); - } - - if (isDestroyed(duplex)) { - const writable = new WritableStream(); - const readable = new ReadableStream(); - writable.close(); - readable.cancel(); - return { readable, writable }; - } - - const writable = isWritable(duplex) - ? newWritableStreamFromStreamWritable(duplex) - : new WritableStream(); - - if (!isWritable(duplex)) writable.close(); - - const readable = isReadable(duplex) - ? newReadableStreamFromStreamReadable(duplex) - : new ReadableStream(); - - if (!isReadable(duplex)) readable.cancel(); - - return { writable, readable }; + // Not using the internal/streams/utils isWritableNodeStream and + // isReadableNodeStream utilities here because they will return false + // if the duplex was created with writable or readable options set to + // false. Instead, we'll check the readable and writable state after + // and return closed WritableStream or closed ReadableStream as + // necessary. + if (typeof duplex?._writableState !== 'object' || + typeof duplex?._readableState !== 'object') { + throw new ERR_INVALID_ARG_TYPE('duplex', 'stream.Duplex', duplex); + } + + if (isDestroyed(duplex)) { + const writable = new WritableStream(); + const readable = new ReadableStream(); + writable.close(); + readable.cancel(); + return { readable, writable }; + } + + const writable = + isWritable(duplex) ? + newWritableStreamFromStreamWritable(duplex) : + new WritableStream(); + + if (!isWritable(duplex)) + writable.close(); + + const readable = + isReadable(duplex) ? + newReadableStreamFromStreamReadable(duplex) : + new ReadableStream(); + + if (!isReadable(duplex)) + readable.cancel(); + + return { writable, readable }; } /** @@ -509,179 +544,187 @@ export function newReadableWritablePairFromDuplex(duplex) { * @returns {Duplex} */ export function newStreamDuplexFromReadableWritablePair(pair = {}, options = {}) { - validateObject(pair, "pair"); - const { readable: readableStream, writable: writableStream } = pair; - - if (!(readableStream instanceof ReadableStream)) { - throw new ERR_INVALID_ARG_TYPE("pair.readable", "ReadableStream", readableStream); - } - if (!(writableStream instanceof WritableStream)) { - throw new ERR_INVALID_ARG_TYPE("pair.writable", "WritableStream", writableStream); - } - - validateObject(options, "options"); - const { - allowHalfOpen = false, - objectMode = false, - encoding, - decodeStrings = true, - highWaterMark, - signal, - } = options; - - validateBoolean(objectMode, "options.objectMode"); - if (encoding !== undefined && !Buffer.isEncoding(encoding)) - throw new ERR_INVALID_ARG_VALUE(encoding, "options.encoding"); - - const writer = writableStream.getWriter(); - const reader = readableStream.getReader(); - let writableClosed = false; - let readableClosed = false; - - const duplex = new Duplex({ - allowHalfOpen, - highWaterMark, - objectMode, - encoding, - decodeStrings, - signal, - - writev(chunks, callback) { - function done(error) { - error = error.filter((e) => e); - try { - callback(error.length === 0 ? undefined : error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => destroy(duplex, error)); - } - } - - writer.ready.then(() => { - return Promise.all( - chunks.map((data) => { - return writer.write(data); - }) - ).then(done, done); - }, done); - }, - - write(chunk, encoding, callback) { - if (typeof chunk === "string" && decodeStrings && !objectMode) { - const enc = normalizeEncoding(encoding); - - if (enc === "utf8") { - chunk = encoder.encode(chunk); - } else { - chunk = Buffer.from(chunk, encoding); - chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength); - } - } - - function done(error) { - try { - callback(error); - } catch (error) { - destroy(duplex, error); - } - } - - writer.ready.then(() => { - return writer.write(chunk).then(done, done); - }, done); - }, - - final(callback) { - function done(error) { - try { - callback(error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => destroy(duplex, error)); - } - } - - if (!writableClosed) { - writer.close().then(done, done); - } - }, - - read() { - reader.read().then( - (chunk) => { - if (chunk.done) { - duplex.push(null); - } else { - duplex.push(chunk.value); - } - }, - (error) => destroy(duplex, error) - ); - }, - - destroy(error, callback) { - function done() { - try { - callback(error); - } catch (error) { - // In a next tick because this is happening within - // a promise context, and if there are any errors - // thrown we don't want those to cause an unhandled - // rejection. Let's just escape the promise and - // handle it separately. - process.nextTick(() => { - throw error; - }); - } - } - - async function closeWriter() { - if (!writableClosed) await writer.abort(error); - } - - async function closeReader() { - if (!readableClosed) await reader.cancel(error); - } - - if (!writableClosed || !readableClosed) { - Promise.all([closeWriter(), closeReader()]).then(done, done); - return; - } - - done(); - }, - }); - - writer.closed.then( - () => { - writableClosed = true; - if (!isWritableEnded(duplex)) destroy(duplex, new ERR_STREAM_PREMATURE_CLOSE()); - }, - (error) => { - writableClosed = true; - readableClosed = true; - destroy(duplex, error); + validateObject(pair, 'pair'); + const { + readable: readableStream, + writable: writableStream, + } = pair; + + if (!(readableStream instanceof ReadableStream)) { + throw new ERR_INVALID_ARG_TYPE( + 'pair.readable', + 'ReadableStream', + readableStream); + } + if (!(writableStream instanceof WritableStream)) { + throw new ERR_INVALID_ARG_TYPE( + 'pair.writable', + 'WritableStream', + writableStream); + } + + validateObject(options, 'options'); + const { + allowHalfOpen = false, + objectMode = false, + encoding, + decodeStrings = true, + highWaterMark, + signal, + } = options; + + validateBoolean(objectMode, 'options.objectMode'); + if (encoding !== undefined && !Buffer.isEncoding(encoding)) + throw new ERR_INVALID_ARG_VALUE(encoding, 'options.encoding'); + + const writer = writableStream.getWriter(); + const reader = readableStream.getReader(); + let writableClosed = false; + let readableClosed = false; + + const duplex = new Duplex({ + allowHalfOpen, + highWaterMark, + objectMode, + encoding, + decodeStrings, + signal, + + writev(chunks, callback) { + function done(error) { + error = error.filter((e) => e); + try { + callback(error.length === 0 ? undefined : error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => destroy(duplex, error)); } - ); - - reader.closed.then( - () => { - readableClosed = true; - }, - (error) => { - writableClosed = true; - readableClosed = true; - destroy(duplex, error); + } + + writer.ready.then(() => { + return Promise.all(chunks.map((data) => { + return writer.write(data); + })).then(done, done); + }, + done); + }, + + write(chunk, encoding, callback) { + if (typeof chunk === 'string' && decodeStrings && !objectMode) { + const enc = normalizeEncoding(encoding); + + if (enc === 'utf8') { + chunk = encoder.encode(chunk); + } else { + chunk = Buffer.from(chunk, encoding); + chunk = new Uint8Array( + chunk.buffer, + chunk.byteOffset, + chunk.byteLength + ); } - ); + } - return duplex; + function done(error) { + try { + callback(error); + } catch (error) { + destroy(duplex, error); + } + } + + writer.ready.then(() => { + return writer.write(chunk).then(done, done); + }, + done); + }, + + final(callback) { + function done(error) { + try { + callback(error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => destroy(duplex, error)); + } + } + + if (!writableClosed) { + writer.close().then(done, done); + } + }, + + read() { + reader.read().then((chunk) => { + if (chunk.done) { + duplex.push(null); + } else { + duplex.push(chunk.value); + } + }, + (error) => destroy(duplex, error)); + }, + + destroy(error, callback) { + function done() { + try { + callback(error); + } catch (error) { + // In a next tick because this is happening within + // a promise context, and if there are any errors + // thrown we don't want those to cause an unhandled + // rejection. Let's just escape the promise and + // handle it separately. + process.nextTick(() => { throw error; }); + } + } + + async function closeWriter() { + if (!writableClosed) + await writer.abort(error); + } + + async function closeReader() { + if (!readableClosed) + await reader.cancel(error); + } + + if (!writableClosed || !readableClosed) { + Promise.all([ closeWriter(), closeReader() ]).then(done, done); + return; + } + + done(); + }, + }); + + writer.closed.then(() => { + writableClosed = true; + if (!isWritableEnded(duplex)) + destroy(duplex, new ERR_STREAM_PREMATURE_CLOSE()); + }, + (error) => { + writableClosed = true; + readableClosed = true; + destroy(duplex, error); + }); + + reader.closed.then(() => { + readableClosed = true; + }, + (error) => { + writableClosed = true; + readableClosed = true; + destroy(duplex, error); + }); + + return duplex; } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_duplex.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_duplex.js index 61439b173..7b2b286c7 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_duplex.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_duplex.js @@ -1,475 +1,479 @@ -import { Readable, from } from "./streams_readable"; +import { + Readable, + from, +} from './streams_readable'; -import { Writable } from "./streams_writable"; +import { + Writable, +} from './streams_writable'; import { - newStreamDuplexFromReadableWritablePair, - newReadableWritablePairFromDuplex, -} from "./streams_adapters"; + newStreamDuplexFromReadableWritablePair, + newReadableWritablePairFromDuplex, +} from './streams_adapters'; -import { createDeferredPromise } from "./internal_utils"; +import { + createDeferredPromise, +} from './internal_utils'; -import * as process from "./process"; +import * as process from './process'; import { - destroyer, - eos, - isReadable, - isWritable, - isIterable, - isNodeStream, - isReadableNodeStream, - isWritableNodeStream, - isDuplexNodeStream, -} from "./streams_util"; + destroyer, + eos, + isReadable, + isWritable, + isIterable, + isNodeStream, + isReadableNodeStream, + isWritableNodeStream, + isDuplexNodeStream, +} from './streams_util'; -import { AbortError, ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE } from "./internal_errors"; +import { + AbortError, + ERR_INVALID_ARG_TYPE, + ERR_INVALID_RETURN_VALUE, +} from './internal_errors'; Object.setPrototypeOf(Duplex.prototype, Readable.prototype); Object.setPrototypeOf(Duplex, Readable); { - const keys = Object.keys(Writable.prototype); - // Allow the keys array to be GC'ed. - for (let i = 0; i < keys.length; i++) { - const method = keys[i]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; - } + const keys = Object.keys(Writable.prototype); + // Allow the keys array to be GC'ed. + for (let i = 0; i < keys.length; i++) { + const method = keys[i]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; + } } export function isDuplexInstance(obj) { - return obj instanceof Duplex; + return obj instanceof Duplex; } export function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - Readable.call(this, options); - Writable.call(this, options); - if (options) { - this.allowHalfOpen = options.allowHalfOpen !== false; - if (options.readable === false) { - this._readableState.readable = false; - this._readableState.ended = true; - this._readableState.endEmitted = true; - } - if (options.writable === false) { - this._writableState.writable = false; - this._writableState.ending = true; - this._writableState.ended = true; - this._writableState.finished = true; - } - } else { - this.allowHalfOpen = true; + if (!(this instanceof Duplex)) return new Duplex(options); + Readable.call(this, options); + Writable.call(this, options); + if (options) { + this.allowHalfOpen = options.allowHalfOpen !== false; + if (options.readable === false) { + this._readableState.readable = false; + this._readableState.ended = true; + this._readableState.endEmitted = true; + } + if (options.writable === false) { + this._writableState.writable = false; + this._writableState.ending = true; + this._writableState.ended = true; + this._writableState.finished = true; } + } else { + this.allowHalfOpen = true; + } } Object.defineProperties(Duplex.prototype, { - writable: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writable"), - }, - writableHighWaterMark: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableHighWaterMark"), - }, - writableObjectMode: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableObjectMode"), - }, - writableBuffer: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableBuffer"), - }, - writableLength: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableLength"), - }, - writableFinished: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableFinished"), - }, - writableCorked: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableCorked"), - }, - writableEnded: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableEnded"), - }, - writableNeedDrain: { - ...Object.getOwnPropertyDescriptor(Writable.prototype, "writableNeedDrain"), - }, - destroyed: { - get() { - if (this._readableState === undefined || this._writableState === undefined) { - return false; - } - return this._readableState.destroyed && this._writableState.destroyed; - }, - set(value) { - // Backward compatibility, the user is explicitly - // managing destroyed. - if (this._readableState && this._writableState) { - this._readableState.destroyed = value; - this._writableState.destroyed = value; - } - }, + writable: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writable') + }, + writableHighWaterMark: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableHighWaterMark') + }, + writableObjectMode: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableObjectMode') + }, + writableBuffer: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableBuffer') + }, + writableLength: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableLength') + }, + writableFinished: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableFinished') + }, + writableCorked: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableCorked') + }, + writableEnded: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableEnded') + }, + writableNeedDrain: { + ...Object.getOwnPropertyDescriptor(Writable.prototype, 'writableNeedDrain') + }, + destroyed: { + get() { + if (this._readableState === undefined || this._writableState === undefined) { + return false + } + return this._readableState.destroyed && this._writableState.destroyed }, + set(value) { + // Backward compatibility, the user is explicitly + // managing destroyed. + if (this._readableState && this._writableState) { + this._readableState.destroyed = value + this._writableState.destroyed = value + } + } + } }); Duplex.fromWeb = function (pair, options) { - return newStreamDuplexFromReadableWritablePair(pair, options); -}; + return newStreamDuplexFromReadableWritablePair(pair, options) +} Duplex.toWeb = function (duplex) { - return newReadableWritablePairFromDuplex(duplex); -}; + return newReadableWritablePairFromDuplex(duplex) +} // ====================================================================================== Duplex.from = function (body) { - return duplexify(body, "body"); -}; + return duplexify(body, 'body') +} function isBlob(b) { - return b instanceof Blob; + return b instanceof Blob; } // This is needed for pre node 17. -class Duplexify extends Duplex { - constructor(options) { - super(options); - // https://github.com/nodejs/node/pull/34385 +class Duplexify extends (Duplex) { + constructor(options) { + super(options); + // https://github.com/nodejs/node/pull/34385 - if ((options === null || options === undefined ? undefined : options.readable) === false) { - this["_readableState"].readable = false; - this["_readableState"].ended = true; - this["_readableState"].endEmitted = true; - } - if ((options === null || options === undefined ? undefined : options.writable) === false) { - this["_readableState"].writable = false; - this["_readableState"].ending = true; - this["_readableState"].ended = true; - this["_readableState"].finished = true; - } + if ((options === null || options === undefined ? undefined : options.readable) === false) { + this['_readableState'].readable = false; + this['_readableState'].ended = true; + this['_readableState'].endEmitted = true; } + if ((options === null || options === undefined ? undefined : options.writable) === false) { + this['_readableState'].writable = false; + this['_readableState'].ending = true; + this['_readableState'].ended = true; + this['_readableState'].finished = true; + } + } } function duplexify(body, name) { - if (isDuplexNodeStream(body)) { - return body; - } - if (isReadableNodeStream(body)) { - return _duplexify({ - readable: body, - }); - } - if (isWritableNodeStream(body)) { - return _duplexify({ - writable: body, - }); - } - if (isNodeStream(body)) { - return _duplexify({ - writable: false, - readable: false, - }); - } + if (isDuplexNodeStream(body)) { + return body; + } + if (isReadableNodeStream(body)) { + return _duplexify({ + readable: body + }); + } + if (isWritableNodeStream(body)) { + return _duplexify({ + writable: body + }); + } + if (isNodeStream(body)) { + return _duplexify({ + writable: false, + readable: false + }); + } - // TODO: Webstreams - // if (isReadableStream(body)) { - // return _duplexify({ readable: Readable.fromWeb(body) }); - // } + // TODO: Webstreams + // if (isReadableStream(body)) { + // return _duplexify({ readable: Readable.fromWeb(body) }); + // } - // TODO: Webstreams - // if (isWritableStream(body)) { - // return _duplexify({ writable: Writable.fromWeb(body) }); - // } + // TODO: Webstreams + // if (isWritableStream(body)) { + // return _duplexify({ writable: Writable.fromWeb(body) }); + // } - if (typeof body === "function") { - const { value, write, final, destroy } = fromAsyncGen(body); - if (isIterable(value)) { - return from(Duplexify, value, { - // TODO (ronag): highWaterMark? - objectMode: true, - write, - final, - destroy, - }); + if (typeof body === 'function') { + const { value, write, final, destroy } = fromAsyncGen(body) + if (isIterable(value)) { + return from(Duplexify, value, { + // TODO (ronag): highWaterMark? + objectMode: true, + write, + final, + destroy + }); + } + const then = value.then; + if (typeof then === 'function') { + let d; + const promise = Reflect.apply(then, value, [ + (val) => { + if (val != null) { + throw new ERR_INVALID_RETURN_VALUE('nully', 'body', val) + } + }, + (err) => { + destroyer(d, err) } - const then = value.then; - if (typeof then === "function") { - let d; - const promise = Reflect.apply(then, value, [ - (val) => { - if (val != null) { - throw new ERR_INVALID_RETURN_VALUE("nully", "body", val); - } - }, - (err) => { - destroyer(d, err); - }, - ]); + ]); - return (d = new Duplexify({ - // TODO (ronag): highWaterMark? - objectMode: true, - readable: false, - write, - final(cb) { - final(async () => { - try { - await promise; - process.nextTick(cb, null); - } catch (err) { - process.nextTick(cb, err); - } - }); - }, - destroy, - })); - } - throw new ERR_INVALID_RETURN_VALUE("Iterable, AsyncIterable or AsyncFunction", name, value); - } - if (isBlob(body)) { - return duplexify(body.arrayBuffer(), name); - } - if (isIterable(body)) { - return from(Duplexify, body, { - // TODO (ronag): highWaterMark? - objectMode: true, - writable: false, - }); + return (d = new Duplexify({ + // TODO (ronag): highWaterMark? + objectMode: true, + readable: false, + write, + final(cb) { + final(async () => { + try { + await promise + process.nextTick(cb, null); + } catch (err) { + process.nextTick(cb, err); + } + }) + }, + destroy + })); } + throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or AsyncFunction', name, value) + } + if (isBlob(body)) { + return duplexify(body.arrayBuffer(), name); + } + if (isIterable(body)) { + return from(Duplexify, body, { + // TODO (ronag): highWaterMark? + objectMode: true, + writable: false + }) + } - // TODO: Webstreams. - // if ( - // isReadableStream(body?.readable) && - // isWritableStream(body?.writable) - // ) { - // return Duplexify.fromWeb(body); - // } + // TODO: Webstreams. + // if ( + // isReadableStream(body?.readable) && + // isWritableStream(body?.writable) + // ) { + // return Duplexify.fromWeb(body); + // } - if ( - typeof (body === null || body === undefined ? undefined : body.writable) === "object" || - typeof (body === null || body === undefined ? undefined : body.readable) === "object" - ) { - const readable = - body !== null && body !== undefined && body.readable - ? isReadableNodeStream( - body === null || body === undefined ? undefined : body.readable - ) - ? body === null || body === undefined - ? undefined - : body.readable - : duplexify(body.readable, name) - : undefined; - const writable = - body !== null && body !== undefined && body.writable - ? isWritableNodeStream( - body === null || body === undefined ? undefined : body.writable - ) - ? body === null || body === undefined - ? undefined - : body.writable - : duplexify(body.writable, name) - : undefined; - return _duplexify({ - readable, - writable, - }); - } - const then = body?.then; - if (typeof then === "function") { - let d; - Reflect.apply(then, body, [ - (val) => { - if (val != null) { - d.push(val); - } - d.push(null); - }, - (err) => { - destroyer(d, err); - }, - ]); + if ( + typeof (body === null || body === undefined ? undefined : body.writable) === 'object' || + typeof (body === null || body === undefined ? undefined : body.readable) === 'object' + ) { + const readable = + body !== null && body !== undefined && body.readable + ? isReadableNodeStream(body === null || body === undefined ? undefined : body.readable) + ? body === null || body === undefined + ? undefined + : body.readable + : duplexify(body.readable, name) + : undefined; + const writable = + body !== null && body !== undefined && body.writable + ? isWritableNodeStream(body === null || body === undefined ? undefined : body.writable) + ? body === null || body === undefined + ? undefined + : body.writable + : duplexify(body.writable, name) + : undefined; + return _duplexify({ + readable, + writable + }); + } + const then = body?.then + if (typeof then === 'function') { + let d; + Reflect.apply(then, body, [ + (val) => { + if (val != null) { + d.push(val); + } + d.push(null); + }, + (err) => { + destroyer(d, err); + } + ]); - return (d = new Duplexify({ - objectMode: true, - writable: false, - read() {}, - })); - } - throw new ERR_INVALID_ARG_TYPE( - name, - [ - "Blob", - "ReadableStream", - "WritableStream", - "Stream", - "Iterable", - "AsyncIterable", - "Function", - "{ readable, writable } pair", - "Promise", - ], - body - ); + return (d = new Duplexify({ + objectMode: true, + writable: false, + read() {} + })); + } + throw new ERR_INVALID_ARG_TYPE( + name, + [ + 'Blob', + 'ReadableStream', + 'WritableStream', + 'Stream', + 'Iterable', + 'AsyncIterable', + 'Function', + '{ readable, writable } pair', + 'Promise' + ], + body + ) } function fromAsyncGen(fn) { - let { promise, resolve } = createDeferredPromise(); - const ac = new AbortController(); - const signal = ac.signal; - const value = fn( - (async function* () { - while (true) { - const _promise = promise; - promise = null; - const { chunk, done, cb } = await _promise; - process.nextTick(cb); - if (done) return; - if (signal.aborted) - throw new AbortError(undefined, { - cause: signal.reason, - }); - ({ promise, resolve } = createDeferredPromise()); - yield chunk; - } - })(), - { - signal, - } - ); - return { - value, - write(chunk, _encoding, cb) { - const _resolve = resolve; - resolve = null; - _resolve({ - chunk, - done: false, - cb, - }); - }, - final(cb) { - const _resolve = resolve; - resolve = null; - _resolve({ - done: true, - cb, - }); - }, - destroy(err, cb) { - ac.abort(); - cb(err); - }, - }; + let { promise, resolve } = createDeferredPromise() + const ac = new AbortController() + const signal = ac.signal + const value = fn( + (async function* () { + while (true) { + const _promise = promise; + promise = null; + const { chunk, done, cb } = await _promise; + process.nextTick(cb); + if (done) return; + if (signal.aborted) + throw new AbortError(undefined, { + cause: signal.reason + }); + ({ promise, resolve } = createDeferredPromise()); + yield chunk; + } + })(), + { + signal + } + ); + return { + value, + write(chunk, _encoding, cb) { + const _resolve = resolve; + resolve = null; + _resolve({ + chunk, + done: false, + cb + }) + }, + final(cb) { + const _resolve = resolve; + resolve = null; + (_resolve)({ + done: true, + cb + }); + }, + destroy(err, cb) { + ac.abort(); + cb(err); + } + } } function _duplexify(pair) { - const r = - pair.readable && typeof pair.readable.read !== "function" - ? Readable.wrap(pair.readable) - : pair.readable; - const w = pair.writable; - let readable = !!isReadable(r); - let writable = !!isWritable(w); - let ondrain; - let onfinish; - let onreadable; - let onclose; - let d; - function onfinished(err) { - const cb = onclose; - onclose = null; - if (cb) { - cb(err); - } else if (err) { - d.destroy(err); - } else if (!readable && !writable) { - d.destroy(); - } + const r = pair.readable && typeof pair.readable.read !== 'function' ? Readable.wrap(pair.readable) : pair.readable; + const w = pair.writable; + let readable = !!isReadable(r); + let writable = !!isWritable(w); + let ondrain; + let onfinish; + let onreadable; + let onclose; + let d; + function onfinished(err) { + const cb = onclose + onclose = null + if (cb) { + cb(err) + } else if (err) { + d.destroy(err) + } else if (!readable && !writable) { + d.destroy() } + } - // TODO(ronag): Avoid double buffering. - // Implement Writable/Readable/Duplex traits. - // See, https://github.com/nodejs/node/pull/33515. - d = new Duplexify({ - // TODO (ronag): highWaterMark? - readableObjectMode: !!(r !== null && r !== undefined && r.readableObjectMode), - writableObjectMode: !!(w !== null && w !== undefined && w.writableObjectMode), - readable, - writable, + // TODO(ronag): Avoid double buffering. + // Implement Writable/Readable/Duplex traits. + // See, https://github.com/nodejs/node/pull/33515. + d = new Duplexify({ + // TODO (ronag): highWaterMark? + readableObjectMode: !!(r !== null && r !== undefined && r.readableObjectMode), + writableObjectMode: !!(w !== null && w !== undefined && w.writableObjectMode), + readable, + writable + }); + if (writable) { + eos(w, (err) => { + writable = false; + if (err) { + destroyer(r, err); + } + onfinished(err); }); - if (writable) { - eos(w, (err) => { - writable = false; - if (err) { - destroyer(r, err); - } - onfinished(err); - }); - d._write = function (chunk, encoding, callback) { - if (w.write(chunk, encoding)) { - callback(); - } else { - ondrain = callback; - } - }; - d._final = function (callback) { - w.end(); - onfinish = callback; - }; - w.on("drain", function () { - if (ondrain) { - const cb = ondrain; - ondrain = null; - cb(); - } - }); - w.on("finish", function () { - if (onfinish) { - const cb = onfinish; - onfinish = null; - cb(); - } - }); - } - if (readable) { - eos(r, (err) => { - readable = false; - if (err) { - destroyer(r, err); - } - onfinished(err); - }); - r.on("readable", function () { - if (onreadable) { - const cb = onreadable; - onreadable = null; - cb(); - } - }); - r.on("end", function () { - d.push(null); - }); - d._read = function () { - while (true) { - const buf = r.read(); - if (buf === null) { - onreadable = d._read; - return; - } - if (!d.push(buf)) { - return; - } - } - }; - } - d._destroy = function (err, callback) { - if (!err && onclose !== null) { - err = new AbortError(); - } - onreadable = null; + d._write = function (chunk, encoding, callback) { + if (w.write(chunk, encoding)) { + callback(); + } else { + ondrain = callback; + } + }; + d._final = function (callback) { + w.end(); + onfinish = callback; + }; + w.on('drain', function () { + if (ondrain) { + const cb = ondrain; ondrain = null; + cb(); + } + }); + w.on('finish', function () { + if (onfinish) { + const cb = onfinish; onfinish = null; - if (onclose === null) { - callback(err); - } else { - onclose = callback; - destroyer(w, err); - destroyer(r, err); + cb(); + } + }); + } + if (readable) { + eos(r, (err) => { + readable = false; + if (err) { + destroyer(r, err); + } + onfinished(err); + }); + r.on('readable', function () { + if (onreadable) { + const cb = onreadable; + onreadable = null; + cb(); + } + }); + r.on('end', function () { + d.push(null); + }); + d._read = function () { + while (true) { + const buf = r.read(); + if (buf === null) { + onreadable = d._read; + return; + } + if (!d.push(buf)) { + return; } + } }; - return d; + } + d._destroy = function (err, callback) { + if (!err && onclose !== null) { + err = new AbortError(); + } + onreadable = null; + ondrain = null; + onfinish = null; + if (onclose === null) { + callback(err); + } else { + onclose = callback; + destroyer(w, err); + destroyer(r, err); + } + } + return d; } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_legacy.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_legacy.js index 1f859aae7..f0b4473df 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_legacy.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_legacy.js @@ -1,83 +1,87 @@ -import EventEmitter from "./events"; -import { Buffer } from "./internal_buffer"; +import + EventEmitter from './events'; + +import { + Buffer, +} from './internal_buffer'; export function Stream(opts) { - EventEmitter.call(this, opts || {}); + EventEmitter.call(this, opts||{}); } Object.setPrototypeOf(Stream.prototype, EventEmitter.prototype); Object.setPrototypeOf(Stream, EventEmitter); Stream.prototype.pipe = function (dest, options) { - const source = this; - function ondata(chunk) { - if (dest.writable && dest.write(chunk) === false && source.pause) { - source.pause(); - } + const source = this; + function ondata(chunk) { + if (dest.writable && dest.write(chunk) === false && source.pause) { + source.pause(); } - source.on("data", ondata); - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } + } + source.on('data', ondata); + function ondrain() { + if (source.readable && source.resume) { + source.resume(); } - dest.on("drain", ondrain); + } + dest.on('drain', ondrain); - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on("end", onend); - source.on("close", onclose); - } - let didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - dest.end(); - } - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - if (typeof dest.destroy === "function") dest.destroy(); - } + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + let didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + dest.end(); + } + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + if (typeof dest.destroy === 'function') dest.destroy(); + } - // Don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, "error") === 0) { - this.emit("error", er); - } + // Don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EventEmitter.listenerCount(this, 'error') === 0) { + this.emit('error', er); } - source.prependListener("error", onerror); - dest.prependListener("error", onerror); + } + source.prependListener('error', onerror); + dest.prependListener('error', onerror); - // Remove all the event listeners that were added. - function cleanup() { - source.removeListener("data", ondata); - dest.removeListener("drain", ondrain); - source.removeListener("end", onend); - source.removeListener("close", onclose); - source.removeListener("error", onerror); - dest.removeListener("error", onerror); - source.removeListener("end", cleanup); - source.removeListener("close", cleanup); - dest.removeListener("close", cleanup); - } - source.on("end", cleanup); - source.on("close", cleanup); - dest.on("close", cleanup); - dest.emit("pipe", source); + // Remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + source.removeListener('end', onend); + source.removeListener('close', onclose); + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + dest.removeListener('close', cleanup); + } + source.on('end', cleanup); + source.on('close', cleanup); + dest.on('close', cleanup); + dest.emit('pipe', source); - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +} // Backwards-compat with node 0.4.x -Stream.Stream = Stream; +Stream.Stream = Stream Stream._isUint8Array = function isUint8Array(value) { - return value instanceof Uint8Array; -}; + return value instanceof Uint8Array; +} Stream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) { - return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength); -}; + return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength); +} diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_readable.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_readable.js index af1d687b6..0066ff927 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_readable.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_readable.js @@ -1,149 +1,157 @@ /* eslint-disable */ import { - nop, - getHighWaterMark, - getDefaultHighWaterMark, - kPaused, - addAbortSignal, - BufferList, - eos, - construct, - destroy, - destroyer, - undestroy, - errorOrDestroy, - finished, -} from "./streams_util"; - -import * as process from "./process"; - -import EventEmitter from "./events"; - -import { Stream } from "./streams_legacy"; + nop, + getHighWaterMark, + getDefaultHighWaterMark, + kPaused, + addAbortSignal, + BufferList, + eos, + construct, + destroy, + destroyer, + undestroy, + errorOrDestroy, + finished, +} from './streams_util'; + +import * as process from './process'; + +import EventEmitter from './events'; import { - newStreamReadableFromReadableStream, - newReadableStreamFromStreamReadable, -} from "./streams_adapters"; + Stream, +} from './streams_legacy'; -import { Buffer } from "./internal_buffer"; +import { + newStreamReadableFromReadableStream, + newReadableStreamFromStreamReadable, +} from './streams_adapters'; import { - AbortError, - aggregateTwoErrors, - ERR_INVALID_ARG_TYPE, - ERR_METHOD_NOT_IMPLEMENTED, - ERR_MISSING_ARGS, - ERR_OUT_OF_RANGE, - ERR_STREAM_PUSH_AFTER_EOF, - ERR_STREAM_UNSHIFT_AFTER_END_EVENT, - ERR_STREAM_NULL_VALUES, -} from "./internal_errors"; + Buffer, +} from './internal_buffer'; -import { validateObject, validateAbortSignal, validateInteger } from "./validators"; +import { + AbortError, + aggregateTwoErrors, + ERR_INVALID_ARG_TYPE, + ERR_METHOD_NOT_IMPLEMENTED, + ERR_MISSING_ARGS, + ERR_OUT_OF_RANGE, + ERR_STREAM_PUSH_AFTER_EOF, + ERR_STREAM_UNSHIFT_AFTER_END_EVENT, + ERR_STREAM_NULL_VALUES, +} from './internal_errors'; -import { StringDecoder } from "./internal_stringdecoder"; +import { + validateObject, + validateAbortSignal, + validateInteger, +} from './validators'; -import { isDuplexInstance } from "./streams_duplex"; +import { StringDecoder } from './internal_stringdecoder'; + +import { isDuplexInstance } from './streams_duplex'; // ====================================================================================== // ReadableState function ReadableState(options, stream, isDuplex) { - // Duplex streams are both readable and writable, but share - // the same options object. - // However, some cases require setting options to different - // values for the readable and the writable sides of the duplex stream. - // These options can be provided separately as readableXXX and writableXXX. - if (typeof isDuplex !== "boolean") isDuplex = isDuplexInstance(stream); - - // Object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away. - this.objectMode = !!options?.objectMode; - if (isDuplex) this.objectMode = this.objectMode || !!options?.readableObjectMode; - - // The point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - this.highWaterMark = options - ? getHighWaterMark(this, options, "readableHighWaterMark", isDuplex) - : getDefaultHighWaterMark(false); - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift(). - this.buffer = new BufferList(); - this.length = 0; - this.pipes = []; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // Stream is still being constructed and cannot be - // destroyed until construction finished or failed. - // Async construction is opt in, therefore we start as - // constructed. - this.constructed = true; - - // A flag to be able to tell if the event 'readable'/'data' is emitted - // immediately, or on a later tick. We set this to true at first, because - // any actions that shouldn't happen until "later" should generally also - // not happen before the first read call. - this.sync = true; - - // Whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - this[kPaused] = null; - - // True if the error was already emitted and should not be thrown again. - this.errorEmitted = false; - - // Should close be emitted on destroy. Defaults to true. - this.emitClose = !options || options.emitClose !== false; - - // Should .destroy() be called after 'end' (and potentially 'finish'). - this.autoDestroy = !options || options.autoDestroy !== false; - - // Has it been destroyed. - this.destroyed = false; - - // Indicates whether the stream has errored. When true no further - // _read calls, 'data' or 'readable' events should occur. This is needed - // since when autoDestroy is disabled we need a way to tell whether the - // stream has failed. - this.errored = null; - - // Indicates whether the stream has finished destroying. - this.closed = false; - - // True if close has been emitted or would have been emitted - // depending on emitClose. - this.closeEmitted = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options?.defaultEncoding || "utf8"; - - // Ref the piped dest which we need a drain event on it - // type: null | Writable | Set. - this.awaitDrainWriters = null; - this.multiAwaitDrain = false; - - // If true, a maybeReadMore has been scheduled. - this.readingMore = false; - this.dataEmitted = false; - this.decoder = null; - this.encoding = null; - if (options && options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream. + // These options can be provided separately as readableXXX and writableXXX. + if (typeof isDuplex !== 'boolean') isDuplex = isDuplexInstance(stream); + + // Object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away. + this.objectMode = !!(options?.objectMode); + if (isDuplex) this.objectMode = this.objectMode || !!(options?.readableObjectMode); + + // The point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + this.highWaterMark = options + ? getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex) + : getDefaultHighWaterMark(false); + + // A linked list is used to store data chunks instead of an array because the + // linked list can remove elements from the beginning faster than + // array.shift(). + this.buffer = new BufferList(); + this.length = 0; + this.pipes = []; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // Stream is still being constructed and cannot be + // destroyed until construction finished or failed. + // Async construction is opt in, therefore we start as + // constructed. + this.constructed = true; + + // A flag to be able to tell if the event 'readable'/'data' is emitted + // immediately, or on a later tick. We set this to true at first, because + // any actions that shouldn't happen until "later" should generally also + // not happen before the first read call. + this.sync = true; + + // Whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + this[kPaused] = null; + + // True if the error was already emitted and should not be thrown again. + this.errorEmitted = false; + + // Should close be emitted on destroy. Defaults to true. + this.emitClose = !options || options.emitClose !== false; + + // Should .destroy() be called after 'end' (and potentially 'finish'). + this.autoDestroy = !options || options.autoDestroy !== false; + + // Has it been destroyed. + this.destroyed = false; + + // Indicates whether the stream has errored. When true no further + // _read calls, 'data' or 'readable' events should occur. This is needed + // since when autoDestroy is disabled we need a way to tell whether the + // stream has failed. + this.errored = null; + + // Indicates whether the stream has finished destroying. + this.closed = false; + + // True if close has been emitted or would have been emitted + // depending on emitClose. + this.closeEmitted = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options?.defaultEncoding || 'utf8'; + + // Ref the piped dest which we need a drain event on it + // type: null | Writable | Set. + this.awaitDrainWriters = null; + this.multiAwaitDrain = false; + + // If true, a maybeReadMore has been scheduled. + this.readingMore = false; + this.dataEmitted = false; + this.decoder = null; + this.encoding = null; + if (options && options.encoding) { + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } } // ====================================================================================== @@ -155,357 +163,355 @@ Object.setPrototypeOf(Readable.prototype, Stream.prototype); Object.setPrototypeOf(Readable, Stream); export function Readable(options) { - if (!(this instanceof Readable)) return new Readable(options); - - // Checking for a Stream.Duplex instance is faster here instead of inside - // the ReadableState constructor, at least with V8 6.5. - const isDuplex = isDuplexInstance(this); - this._readableState = new ReadableState(options, this, isDuplex); - if (options) { - if (typeof options.read === "function") this._read = options.read; - if (typeof options.destroy === "function") this._destroy = options.destroy; - if (typeof options.construct === "function") this._construct = options.construct; - if (options.signal && !isDuplex) addAbortSignal(options.signal, this); - } - Stream.call(this, options); - construct(this, () => { - if (this._readableState.needReadable) { - maybeReadMore(this, this._readableState); - } - }); + if (!(this instanceof Readable)) return new Readable(options); + + // Checking for a Stream.Duplex instance is faster here instead of inside + // the ReadableState constructor, at least with V8 6.5. + const isDuplex = isDuplexInstance(this); + this._readableState = new ReadableState(options, this, isDuplex); + if (options) { + if (typeof options.read === 'function') this._read = options.read; + if (typeof options.destroy === 'function') this._destroy = options.destroy; + if (typeof options.construct === 'function') this._construct = options.construct; + if (options.signal && !isDuplex) addAbortSignal(options.signal, this); + } + Stream.call(this, options); + construct(this, () => { + if (this._readableState.needReadable) { + maybeReadMore(this, this._readableState); + } + }); } -Readable.prototype.destroy = destroy; -Readable.prototype._undestroy = undestroy; +Readable.prototype.destroy = destroy +Readable.prototype._undestroy = undestroy Readable.prototype._destroy = function (err, cb) { - if (cb) cb(err); -}; + if (cb) cb(err); +} Readable.prototype[EventEmitter.captureRejectionSymbol] = function (err) { - this.destroy(err); -}; + this.destroy(err); +} // Manually shove something into the read() buffer. // This returns true if the highWaterMark has not been hit yet, // similar to how Writable.write() returns true if you should // write() some more. Readable.prototype.push = function (chunk, encoding) { - return readableAddChunk(this, chunk, encoding, false); -}; + return readableAddChunk(this, chunk, encoding, false); +} // Unshift should *always* be something directly out of read(). Readable.prototype.unshift = function (chunk, encoding) { - return readableAddChunk(this, chunk, encoding, true); -}; + return readableAddChunk(this, chunk, encoding, true); +} function readableAddChunk(stream, chunk, encoding, addToFront) { - const state = stream._readableState; - let err; - if (!state.objectMode) { - if (typeof chunk === "string") { - encoding ||= state.defaultEncoding; - if (state.encoding !== encoding) { - if (addToFront && state.encoding) { - // When unshifting, if state.encoding is set, we have to save - // the string in the BufferList with the state encoding. - chunk = Buffer.from(chunk, encoding).toString(state.encoding); - } else { - chunk = Buffer.from(chunk, encoding); - encoding = ""; - } - } - } else if (chunk instanceof Buffer) { - encoding = ""; - } else if (Stream._isUint8Array(chunk)) { - chunk = Stream._uint8ArrayToBuffer(chunk); - encoding = ""; - } else if (chunk != null) { - err = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk); - } - } - if (err) { - errorOrDestroy(stream, err); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || (chunk && chunk.length > 0)) { - if (addToFront) { - if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT()); - else if (state.destroyed || state.errored) return false; - else addChunk(stream, state, chunk, true); - } else if (state.ended) { - errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF()); - } else if (state.destroyed || state.errored) { - return false; + const state = stream._readableState; + let err; + if (!state.objectMode) { + if (typeof chunk === 'string') { + encoding ||= state.defaultEncoding; + if (state.encoding !== encoding) { + if (addToFront && state.encoding) { + // When unshifting, if state.encoding is set, we have to save + // the string in the BufferList with the state encoding. + chunk = Buffer.from(chunk, encoding).toString(state.encoding); } else { - state.reading = false; - if (state.decoder && !encoding) { - chunk = state.decoder.write(chunk); - if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false); - else maybeReadMore(stream, state); - } else { - addChunk(stream, state, chunk, false); - } + chunk = Buffer.from(chunk, encoding); + encoding = ''; } - } else if (!addToFront) { - state.reading = false; - maybeReadMore(stream, state); - } + } + } else if (chunk instanceof Buffer) { + encoding = '' + } else if (Stream._isUint8Array(chunk)) { + chunk = Stream._uint8ArrayToBuffer(chunk); + encoding = ''; + } else if (chunk != null) { + err = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk); + } + } + if (err) { + errorOrDestroy(stream, err); + } else if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else if (state.objectMode || (chunk && chunk.length > 0)) { + if (addToFront) { + if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT()); + else if (state.destroyed || state.errored) return false; + else addChunk(stream, state, chunk, true); + } else if (state.ended) { + errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF()); + } else if (state.destroyed || state.errored) { + return false; + } else { + state.reading = false; + if (state.decoder && !encoding) { + chunk = state.decoder.write(chunk); + if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false); + else maybeReadMore(stream, state); + } else { + addChunk(stream, state, chunk, false); + } + } + } else if (!addToFront) { + state.reading = false; + maybeReadMore(stream, state); + } - // We can push more data if we are below the highWaterMark. - // Also, if we have no data yet, we can stand some more bytes. - // This is to work around cases where hwm=0, such as the repl. - return !state.ended && (state.length < state.highWaterMark || state.length === 0); + // We can push more data if we are below the highWaterMark. + // Also, if we have no data yet, we can stand some more bytes. + // This is to work around cases where hwm=0, such as the repl. + return !state.ended && (state.length < state.highWaterMark || state.length === 0); } function addChunk(stream, state, chunk, addToFront) { - if (state.flowing && state.length === 0 && !state.sync && stream.listenerCount("data") > 0) { - // Use the guard to avoid creating `Set()` repeatedly - // when we have multiple pipes. - if (state.multiAwaitDrain) { - state.awaitDrainWriters.clear(); - } else { - state.awaitDrainWriters = null; - state.multiAwaitDrain = false; - } - state.dataEmitted = true; - stream.emit("data", chunk); + if (state.flowing && state.length === 0 && !state.sync && stream.listenerCount('data') > 0) { + // Use the guard to avoid creating `Set()` repeatedly + // when we have multiple pipes. + if (state.multiAwaitDrain) { + state.awaitDrainWriters.clear(); } else { - // Update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk); - else state.buffer.push(chunk); - if (state.needReadable) emitReadable(stream); - } - maybeReadMore(stream, state); + state.awaitDrainWriters = null; + state.multiAwaitDrain = false; + } + state.dataEmitted = true; + stream.emit('data', chunk); + } else { + // Update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk); + else state.buffer.push(chunk); + if (state.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state); } Readable.prototype.isPaused = function () { - const state = this._readableState; - return state[kPaused] === true || state.flowing === false; -}; + const state = this._readableState; + return state[kPaused] === true || state.flowing === false; +} // Backwards compatibility. Readable.prototype.setEncoding = function (enc) { - const decoder = new StringDecoder(enc); - this._readableState.decoder = decoder; - // If setEncoding(null), decoder.encoding equals utf8. - this._readableState.encoding = decoder.encoding; - const buffer = this._readableState.buffer; - // Iterate over current buffer to convert already stored Buffers: - let content = ""; - for (const data of buffer) { - content += decoder.write(data); - } - buffer.clear(); - if (content !== "") buffer.push(content); - this._readableState.length = content.length; - return this; -}; + const decoder = new StringDecoder(enc); + this._readableState.decoder = decoder; + // If setEncoding(null), decoder.encoding equals utf8. + this._readableState.encoding = decoder.encoding; + const buffer = this._readableState.buffer; + // Iterate over current buffer to convert already stored Buffers: + let content = ''; + for (const data of buffer) { + content += decoder.write(data); + } + buffer.clear(); + if (content !== '') buffer.push(content); + this._readableState.length = content.length; + return this; +} // Don't raise the hwm > 1GB. const MAX_HWM = 0x40000000; function computeNewHighWaterMark(n) { - if (n > MAX_HWM) { - throw new ERR_OUT_OF_RANGE("size", "<= 1GiB", n); - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts. - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; + if (n > MAX_HWM) { + throw new ERR_OUT_OF_RANGE('size', '<= 1GiB', n); + } else { + // Get the next highest power of 2 to prevent increasing hwm excessively in + // tiny amounts. + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; } // This function is designed to be inlinable, so please take care when making // changes to the function body. function howMuchToRead(n, state) { - if (n <= 0 || (state.length === 0 && state.ended)) return 0; - if (state.objectMode) return 1; - if (Number.isNaN(n)) { - // Only flow one buffer at a time. - if (state.flowing && state.length) return state.buffer.first().length; - return state.length; - } - if (n <= state.length) return n; - return state.ended ? state.length : 0; + if (n <= 0 || (state.length === 0 && state.ended)) return 0; + if (state.objectMode) return 1; + if (Number.isNaN(n)) { + // Only flow one buffer at a time. + if (state.flowing && state.length) return state.buffer.first().length; + return state.length; + } + if (n <= state.length) return n; + return state.ended ? state.length : 0; } // You can override either this method, or the async _read(n) below. Readable.prototype.read = function (n) { - // Same as parseInt(undefined, 10), however V8 7.3 performance regressed - // in this scenario, so we are doing it manually. - if (n === undefined) { - n = NaN; - } else if (!Number.isInteger(n)) { - n = Number.parseInt(`${n}`, 10); - } - const state = this._readableState; - const nOrig = n; - - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n !== 0) state.emittedReadable = false; - - // If we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if ( - n === 0 && - state.needReadable && - ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || - state.ended) - ) { - if (state.length === 0 && state.ended) endReadable(this); - else emitReadable(this); - return null; - } - n = howMuchToRead(n, state); - - // If we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - let doRead = state.needReadable; - - // If we currently have less than the highWaterMark, then also read some. - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - } - - // However, if we've ended, then there's no point, if we're already - // reading, then it's unnecessary, if we're constructing we have to wait, - // and if we're destroyed or errored, then it's not allowed, - if (state.ended || state.reading || state.destroyed || state.errored || !state.constructed) { - doRead = false; - } else if (doRead) { - state.reading = true; - state.sync = true; - // If the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - - // Call internal read method - try { - this._read(state.highWaterMark); - } catch (err) { - errorOrDestroy(this, err); - } - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - let ret; - if (n > 0) ret = fromList(n, state); - else ret = null; - if (ret === null) { - state.needReadable = state.length <= state.highWaterMark; - n = 0; + // Same as parseInt(undefined, 10), however V8 7.3 performance regressed + // in this scenario, so we are doing it manually. + if (n === undefined) { + n = NaN; + } else if (!Number.isInteger(n)) { + n = Number.parseInt(`${n}`, 10); + } + const state = this._readableState; + const nOrig = n; + + // If we're asking for more than the current hwm, then raise the hwm. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + if (n !== 0) state.emittedReadable = false; + + // If we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if ( + n === 0 && + state.needReadable && + ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) { + if (state.length === 0 && state.ended) endReadable(this); + else emitReadable(this); + return null; + } + n = howMuchToRead(n, state); + + // If we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + let doRead = state.needReadable; + + // If we currently have less than the highWaterMark, then also read some. + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + } + + // However, if we've ended, then there's no point, if we're already + // reading, then it's unnecessary, if we're constructing we have to wait, + // and if we're destroyed or errored, then it's not allowed, + if (state.ended || state.reading || state.destroyed || state.errored || !state.constructed) { + doRead = false; + } else if (doRead) { + state.reading = true; + state.sync = true; + // If the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + + // Call internal read method + try { + this._read(state.highWaterMark); + } catch (err) { + errorOrDestroy(this, err); + } + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (!state.reading) n = howMuchToRead(nOrig, state); + } + let ret; + if (n > 0) ret = fromList(n, state); + else ret = null; + if (ret === null) { + state.needReadable = state.length <= state.highWaterMark; + n = 0; + } else { + state.length -= n; + if (state.multiAwaitDrain) { + state.awaitDrainWriters.clear(); } else { - state.length -= n; - if (state.multiAwaitDrain) { - state.awaitDrainWriters.clear(); - } else { - state.awaitDrainWriters = null; - state.multiAwaitDrain = false; - } - } - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - if (ret !== null && !state.errorEmitted && !state.closeEmitted) { - state.dataEmitted = true; - this.emit("data", ret); - } - return ret; -}; + state.awaitDrainWriters = null; + state.multiAwaitDrain = false; + } + } + if (state.length === 0) { + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (!state.ended) state.needReadable = true + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended) endReadable(this) + } + if (ret !== null && !state.errorEmitted && !state.closeEmitted) { + state.dataEmitted = true + this.emit('data', ret) + } + return ret +} function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - const chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - if (state.sync) { - // If we are sync, wait until next tick to emit the data. - // Otherwise we risk emitting data in the flow() - // the readable code triggers during a read() call. - emitReadable(stream); - } else { - // Emit 'readable' now to make sure it gets picked up. - state.needReadable = false; - state.emittedReadable = true; - // We have to emit readable now that we are EOF. Modules - // in the ecosystem (e.g. dicer) rely on this event being sync. - emitReadable_(stream); - } + if (state.ended) return; + if (state.decoder) { + const chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + if (state.sync) { + // If we are sync, wait until next tick to emit the data. + // Otherwise we risk emitting data in the flow() + // the readable code triggers during a read() call. + emitReadable(stream); + } else { + // Emit 'readable' now to make sure it gets picked up. + state.needReadable = false; + state.emittedReadable = true; + // We have to emit readable now that we are EOF. Modules + // in the ecosystem (e.g. dicer) rely on this event being sync. + emitReadable_(stream); + } } // Don't emit readable right away in sync mode, because this can trigger // another read() call => stack overflow. This way, it might trigger // a nextTick recursion warning, but that's not so bad. function emitReadable(stream) { - const state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - state.emittedReadable = true; - process.nextTick(emitReadable_, stream); - } + const state = stream._readableState; + state.needReadable = false; + if (!state.emittedReadable) { + state.emittedReadable = true; + process.nextTick(emitReadable_, stream); + } } function emitReadable_(stream) { - const state = stream._readableState; - if (!state.destroyed && !state.errored && (state.length || state.ended)) { - stream.emit("readable"); - state.emittedReadable = false; - } - - // The stream needs another readable event if: - // 1. It is not flowing, as the flow mechanism will take - // care of it. - // 2. It is not ended. - // 3. It is below the highWaterMark, so we can schedule - // another readable later. - state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark; - flow(stream); + const state = stream._readableState; + if (!state.destroyed && !state.errored && (state.length || state.ended)) { + stream.emit('readable'); + state.emittedReadable = false; + } + + // The stream needs another readable event if: + // 1. It is not flowing, as the flow mechanism will take + // care of it. + // 2. It is not ended. + // 3. It is below the highWaterMark, so we can schedule + // another readable later. + state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark; + flow(stream); } // At this point, the user has presumably seen the 'readable' event, @@ -515,48 +521,48 @@ function emitReadable_(stream) { // However, if we're not ended, or reading, and the length < hwm, // then go ahead and try to read some more preemptively. function maybeReadMore(stream, state) { - if (!state.readingMore && state.constructed) { - state.readingMore = true; - process.nextTick(maybeReadMore_, stream, state); - } + if (!state.readingMore && state.constructed) { + state.readingMore = true; + process.nextTick(maybeReadMore_, stream, state); + } } function maybeReadMore_(stream, state) { - // Attempt to read more data if we should. - // - // The conditions for reading more data are (one of): - // - Not enough data buffered (state.length < state.highWaterMark). The loop - // is responsible for filling the buffer with enough data if such data - // is available. If highWaterMark is 0 and we are not in the flowing mode - // we should _not_ attempt to buffer any extra data. We'll get more data - // when the stream consumer calls read() instead. - // - No data in the buffer, and the stream is in flowing mode. In this mode - // the loop below is responsible for ensuring read() is called. Failing to - // call read here would abort the flow and there's no other mechanism for - // continuing the flow if the stream consumer has just subscribed to the - // 'data' event. - // - // In addition to the above conditions to keep reading data, the following - // conditions prevent the data from being read: - // - The stream has ended (state.ended). - // - There is already a pending 'read' operation (state.reading). This is a - // case where the stream has called the implementation defined _read() - // method, but they are processing the call asynchronously and have _not_ - // called push() with new data. In this case we skip performing more - // read()s. The execution ends in this method again after the _read() ends - // up calling push() with more data. - while ( - !state.reading && - !state.ended && - (state.length < state.highWaterMark || (state.flowing && state.length === 0)) - ) { - const len = state.length; - stream.read(0); - if (len === state.length) - // Didn't get any data, stop spinning. - break; - } - state.readingMore = false; + // Attempt to read more data if we should. + // + // The conditions for reading more data are (one of): + // - Not enough data buffered (state.length < state.highWaterMark). The loop + // is responsible for filling the buffer with enough data if such data + // is available. If highWaterMark is 0 and we are not in the flowing mode + // we should _not_ attempt to buffer any extra data. We'll get more data + // when the stream consumer calls read() instead. + // - No data in the buffer, and the stream is in flowing mode. In this mode + // the loop below is responsible for ensuring read() is called. Failing to + // call read here would abort the flow and there's no other mechanism for + // continuing the flow if the stream consumer has just subscribed to the + // 'data' event. + // + // In addition to the above conditions to keep reading data, the following + // conditions prevent the data from being read: + // - The stream has ended (state.ended). + // - There is already a pending 'read' operation (state.reading). This is a + // case where the stream has called the implementation defined _read() + // method, but they are processing the call asynchronously and have _not_ + // called push() with new data. In this case we skip performing more + // read()s. The execution ends in this method again after the _read() ends + // up calling push() with more data. + while ( + !state.reading && + !state.ended && + (state.length < state.highWaterMark || (state.flowing && state.length === 0)) + ) { + const len = state.length; + stream.read(0); + if (len === state.length) + // Didn't get any data, stop spinning. + break; + } + state.readingMore = false; } // Abstract method. to be overridden in specific implementation classes. @@ -564,1200 +570,1183 @@ function maybeReadMore_(stream, state) { // for virtual (non-string, non-buffer) streams, "length" is somewhat // arbitrary, and perhaps not very meaningful. Readable.prototype._read = function (_size) { - throw new ERR_METHOD_NOT_IMPLEMENTED("_read()"); -}; + throw new ERR_METHOD_NOT_IMPLEMENTED('_read()'); +} Readable.prototype.pipe = function (dest, pipeOpts) { - const src = this; - const state = this._readableState; - if (state.pipes.length === 1) { - if (!state.multiAwaitDrain) { - state.multiAwaitDrain = true; - state.awaitDrainWriters = new Set( - state.awaitDrainWriters ? [state.awaitDrainWriters] : [] - ); - } - } - state.pipes.push(dest); - const doEnd = !pipeOpts || pipeOpts.end !== false; - const endFn = doEnd ? onend : unpipe; - if (state.endEmitted) process.nextTick(endFn); - else src.once("end", endFn); - dest.on("unpipe", onunpipe); - function onunpipe(readable, unpipeInfo) { - if (readable === src) { - if (unpipeInfo && unpipeInfo.hasUnpiped === false) { - unpipeInfo.hasUnpiped = true; - cleanup(); - } - } - } - function onend() { - dest.end(); - } - let ondrain; - let cleanedUp = false; - function cleanup() { - // Cleanup event handlers once the pipe is broken. - dest.removeListener("close", onclose); - dest.removeListener("finish", onfinish); - if (ondrain) { - dest.removeListener("drain", ondrain); - } - dest.removeListener("error", onerror); - dest.removeListener("unpipe", onunpipe); - src.removeListener("end", onend); - src.removeListener("end", unpipe); - src.removeListener("data", ondata); - cleanedUp = true; - - // If the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if ( - ondrain && - state.awaitDrainWriters && - (!dest._writableState || dest._writableState.needDrain) - ) - ondrain(); - } - function pause() { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if (!cleanedUp) { - if (state.pipes.length === 1 && state.pipes[0] === dest) { - state.awaitDrainWriters = dest; - state.multiAwaitDrain = false; - } else if (state.pipes.length > 1 && state.pipes.includes(dest)) { - state.awaitDrainWriters.add(dest); - } - src.pause(); - } - if (!ondrain) { - // When the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - ondrain = pipeOnDrain(src, dest); - dest.on("drain", ondrain); - } - } - src.on("data", ondata); - function ondata(chunk) { - const ret = dest.write(chunk); - if (ret === false) { - pause(); - } - } - - // If the dest has an error, then stop piping into it. - // However, don't suppress the throwing behavior for this. - function onerror(er) { - unpipe(); - dest.removeListener("error", onerror); - if (dest.listenerCount("error") === 0) { - const s = dest._writableState || dest._readableState; - if (s && !s.errorEmitted) { - // User incorrectly emitted 'error' directly on the stream. - errorOrDestroy(dest, er); - } else { - dest.emit("error", er); - } - } - } - - // Make sure our error handler is attached before userland ones. - dest.prependListener("error", onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener("finish", onfinish); - unpipe(); - } - dest.once("close", onclose); - function onfinish() { - dest.removeListener("close", onclose); - unpipe(); - } - dest.once("finish", onfinish); - function unpipe() { - src.unpipe(dest); - } - - // Tell the dest that it's being piped to. - dest.emit("pipe", src); - - // Start the flow if it hasn't been started already. - - if (dest.writableNeedDrain === true) { - if (state.flowing) { - pause(); - } - } else if (!state.flowing) { - src.resume(); - } - return dest; -}; + const src = this; + const state = this._readableState; + if (state.pipes.length === 1) { + if (!state.multiAwaitDrain) { + state.multiAwaitDrain = true; + state.awaitDrainWriters = new Set( + state.awaitDrainWriters ? [state.awaitDrainWriters] : []); + } + } + state.pipes.push(dest); + const doEnd = (!pipeOpts || pipeOpts.end !== false); + const endFn = doEnd ? onend : unpipe; + if (state.endEmitted) process.nextTick(endFn); + else src.once('end', endFn); + dest.on('unpipe', onunpipe); + function onunpipe(readable, unpipeInfo) { + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + function onend() { + dest.end(); + } + let ondrain; + let cleanedUp = false; + function cleanup() { + // Cleanup event handlers once the pipe is broken. + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + if (ondrain) { + dest.removeListener('drain', ondrain); + } + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', unpipe); + src.removeListener('data', ondata); + cleanedUp = true; + + // If the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (ondrain && state.awaitDrainWriters && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + function pause() { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + // => Check whether `dest` is still a piping destination. + if (!cleanedUp) { + if (state.pipes.length === 1 && state.pipes[0] === dest) { + state.awaitDrainWriters = dest; + state.multiAwaitDrain = false; + } else if (state.pipes.length > 1 && state.pipes.includes(dest)) { + state.awaitDrainWriters.add(dest); + } + src.pause(); + } + if (!ondrain) { + // When the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + ondrain = pipeOnDrain(src, dest); + dest.on('drain', ondrain); + } + } + src.on('data', ondata); + function ondata(chunk) { + const ret = dest.write(chunk); + if (ret === false) { + pause(); + } + } + + // If the dest has an error, then stop piping into it. + // However, don't suppress the throwing behavior for this. + function onerror(er) { + unpipe(); + dest.removeListener('error', onerror); + if (dest.listenerCount('error') === 0) { + const s = dest._writableState || dest._readableState; + if (s && !s.errorEmitted) { + // User incorrectly emitted 'error' directly on the stream. + errorOrDestroy(dest, er); + } else { + dest.emit('error', er); + } + } + } + + // Make sure our error handler is attached before userland ones. + dest.prependListener('error', onerror); + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + function unpipe() { + src.unpipe(dest); + } + + // Tell the dest that it's being piped to. + dest.emit('pipe', src); + + // Start the flow if it hasn't been started already. + + if (dest.writableNeedDrain === true) { + if (state.flowing) { + pause(); + } + } else if (!state.flowing) { + src.resume(); + } + return dest; +} function pipeOnDrain(src, dest) { - return function pipeOnDrainFunctionResult() { - const state = src._readableState; - - // `ondrain` will call directly, - // `this` maybe not a reference to dest, - // so we use the real dest here. - if (state.awaitDrainWriters === dest) { - state.awaitDrainWriters = null; - } else if (state.multiAwaitDrain) { - state.awaitDrainWriters.delete(dest); - } - if ( - (!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) && - src.listenerCount("data") - ) { - src.resume(); - } - }; + return function pipeOnDrainFunctionResult() { + const state = src._readableState; + + // `ondrain` will call directly, + // `this` maybe not a reference to dest, + // so we use the real dest here. + if (state.awaitDrainWriters === dest) { + state.awaitDrainWriters = null; + } else if (state.multiAwaitDrain) { + state.awaitDrainWriters.delete(dest); + } + if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) && + src.listenerCount('data')) { + src.resume(); + } + } } Readable.prototype.unpipe = function (dest) { - const state = this._readableState; - const unpipeInfo = { - hasUnpiped: false, - }; - - // If we're not piping anywhere, then do nothing. - if (state.pipes.length === 0) return this; - if (!dest) { - // remove all. - const dests = state.pipes; - state.pipes = []; - this.pause(); - for (let i = 0; i < dests.length; i++) - dests[i].emit("unpipe", this, { - hasUnpiped: false, - }); - return this; - } - - // Try to find the right one. - const index = state.pipes.indexOf(dest); - if (index === -1) return this; - state.pipes.splice(index, 1); - if (state.pipes.length === 0) this.pause(); - dest.emit("unpipe", this, unpipeInfo); + const state = this._readableState; + const unpipeInfo = { + hasUnpiped: false + }; + + // If we're not piping anywhere, then do nothing. + if (state.pipes.length === 0) return this; + if (!dest) { + // remove all. + const dests = state.pipes; + state.pipes = []; + this.pause(); + for (let i = 0; i < dests.length; i++) + dests[i].emit('unpipe', this, { + hasUnpiped: false + }) return this; -}; + } + + // Try to find the right one. + const index = state.pipes.indexOf(dest); + if (index === -1) return this; + state.pipes.splice(index, 1); + if (state.pipes.length === 0) this.pause(); + dest.emit('unpipe', this, unpipeInfo); + return this; +} // Set up data events if they are asked for // Ensure readable listeners eventually get something. Readable.prototype.on = function (ev, fn) { - const res = Stream.prototype.on.call(this, ev, fn); - const state = this._readableState; - if (ev === "data") { - // Update readableListening so that resume() may be a no-op - // a few lines down. This is needed to support once('readable'). - state.readableListening = this.listenerCount("readable") > 0; - - // Try start flowing on next tick if stream isn't explicitly paused. - if (state.flowing !== false) this.resume(); - } else if (ev === "readable") { - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.flowing = false; - state.emittedReadable = false; - if (state.length) { - emitReadable(this); - } else if (!state.reading) { - process.nextTick(nReadingNextTick, this); - } - } - } - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; + const res = Stream.prototype.on.call(this, ev, fn); + const state = this._readableState; + if (ev === 'data') { + // Update readableListening so that resume() may be a no-op + // a few lines down. This is needed to support once('readable'). + state.readableListening = this.listenerCount('readable') > 0; + + // Try start flowing on next tick if stream isn't explicitly paused. + if (state.flowing !== false) this.resume(); + } else if (ev === 'readable') { + if (!state.endEmitted && !state.readableListening) { + state.readableListening = state.needReadable = true; + state.flowing = false; + state.emittedReadable = false; + if (state.length) { + emitReadable(this); + } else if (!state.reading) { + process.nextTick(nReadingNextTick, this); + } + } + } + return res; +} +Readable.prototype.addListener = Readable.prototype.on Readable.prototype.removeListener = function (ev, fn) { - const res = Stream.prototype.removeListener.call(this, ev, fn); - if (ev === "readable") { - // We need to check if there is someone still listening to - // readable and reset the state. However this needs to happen - // after readable has been emitted but before I/O (nextTick) to - // support once('readable', fn) cycles. This means that calling - // resume within the same tick will have no - // effect. - process.nextTick(updateReadableListening, this); - } - return res; -}; -Readable.prototype.off = Readable.prototype.removeListener; + const res = Stream.prototype.removeListener.call(this, ev, fn); + if (ev === 'readable') { + // We need to check if there is someone still listening to + // readable and reset the state. However this needs to happen + // after readable has been emitted but before I/O (nextTick) to + // support once('readable', fn) cycles. This means that calling + // resume within the same tick will have no + // effect. + process.nextTick(updateReadableListening, this); + } + return res; +} +Readable.prototype.off = Readable.prototype.removeListener Readable.prototype.removeAllListeners = function (ev) { - const res = Stream.prototype.removeAllListeners.apply(this, arguments); - if (ev === "readable" || ev === undefined) { - // We need to check if there is someone still listening to - // readable and reset the state. However this needs to happen - // after readable has been emitted but before I/O (nextTick) to - // support once('readable', fn) cycles. This means that calling - // resume within the same tick will have no - // effect. - process.nextTick(updateReadableListening, this); - } - return res; -}; + const res = Stream.prototype.removeAllListeners.apply(this, arguments); + if (ev === 'readable' || ev === undefined) { + // We need to check if there is someone still listening to + // readable and reset the state. However this needs to happen + // after readable has been emitted but before I/O (nextTick) to + // support once('readable', fn) cycles. This means that calling + // resume within the same tick will have no + // effect. + process.nextTick(updateReadableListening, this); + } + return res; +} function updateReadableListening(self) { - const state = self._readableState; - state.readableListening = self.listenerCount("readable") > 0; - if (state.resumeScheduled && state[kPaused] === false) { - // Flowing needs to be set to true now, otherwise - // the upcoming resume will not flow. - state.flowing = true; - - // Crude way to check if we should resume. - } else if (self.listenerCount("data") > 0) { - self.resume(); - } else if (!state.readableListening) { - state.flowing = null; - } + const state = self._readableState; + state.readableListening = self.listenerCount('readable') > 0; + if (state.resumeScheduled && state[kPaused] === false) { + // Flowing needs to be set to true now, otherwise + // the upcoming resume will not flow. + state.flowing = true; + + // Crude way to check if we should resume. + } else if (self.listenerCount('data') > 0) { + self.resume(); + } else if (!state.readableListening) { + state.flowing = null; + } } function nReadingNextTick(self) { - self.read(0); + self.read(0); } // pause() and resume() are remnants of the legacy readable stream API // If the user uses them, then switch into old mode. Readable.prototype.resume = function () { - const state = this._readableState; - if (!state.flowing) { - // We flow only if there is no one listening - // for readable, but we still have to call - // resume(). - state.flowing = !state.readableListening; - resume(this, state); - } - state[kPaused] = false; - return this; -}; + const state = this._readableState; + if (!state.flowing) { + // We flow only if there is no one listening + // for readable, but we still have to call + // resume(). + state.flowing = !state.readableListening; + resume(this, state); + } + state[kPaused] = false; + return this; +} function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - process.nextTick(resume_, stream, state); - } + if (!state.resumeScheduled) { + state.resumeScheduled = true; + process.nextTick(resume_, stream, state); + } } function resume_(stream, state) { - if (!state.reading) { - stream.read(0); - } - state.resumeScheduled = false; - stream.emit("resume"); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); + if (!state.reading) { + stream.read(0); + } + state.resumeScheduled = false; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); } Readable.prototype.pause = function () { - if (this._readableState.flowing !== false) { - this._readableState.flowing = false; - this.emit("pause"); - } - this._readableState[kPaused] = true; - return this; -}; + if (this._readableState.flowing !== false) { + this._readableState.flowing = false; + this.emit('pause'); + } + this._readableState[kPaused] = true; + return this; +} function flow(stream) { - const state = stream._readableState; - while (state.flowing && stream.read() !== null); + const state = stream._readableState; + while (state.flowing && stream.read() !== null); } // Wrap an old-style stream as the async data source. // This is *not* part of the readable stream interface. // It is an ugly unfortunate mess of history. Readable.prototype.wrap = function (stream) { - let paused = false; - - // TODO (ronag): Should this.destroy(err) emit - // 'error' on the wrapped stream? Would require - // a static factory method, e.g. Readable.wrap(stream). - stream.on("data", (chunk) => { - if (!this.push(chunk) && stream.pause) { - paused = true; - stream.pause(); - } - }); - - stream.on("end", () => { - this.push(null); - }); - stream.on("error", (err) => { - errorOrDestroy(this, err); - }); - stream.on("close", () => { - this.destroy(); - }); - stream.on("destroy", () => { - this.destroy(); - }); - this._read = () => { - if (paused && stream.resume) { - paused = false; - stream.resume(); - } - }; - - // Proxy all the other methods. Important when wrapping filters and duplexes. - const streamKeys = Object.keys(stream); - for (let j = 1; j < streamKeys.length; j++) { - const i = streamKeys[j]; - if (this[i] === undefined && typeof stream[i] === "function") { - this[i] = stream[i].bind(stream); - } - } - return this; -}; + let paused = false; + + // TODO (ronag): Should this.destroy(err) emit + // 'error' on the wrapped stream? Would require + // a static factory method, e.g. Readable.wrap(stream). + stream.on('data', (chunk) => { + if (!this.push(chunk) && stream.pause) { + paused = true; + stream.pause(); + } + }); + + stream.on('end', () => { + this.push(null); + }); + stream.on('error', (err) => { + errorOrDestroy(this, err); + }); + stream.on('close', () => { + this.destroy(); + }); + stream.on('destroy', () => { + this.destroy(); + }); + this._read = () => { + if (paused && stream.resume) { + paused = false; + stream.resume(); + } + }; + + // Proxy all the other methods. Important when wrapping filters and duplexes. + const streamKeys = Object.keys(stream); + for (let j = 1; j < streamKeys.length; j++) { + const i = streamKeys[j]; + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = stream[i].bind(stream); + } + } + return this; +} Readable.prototype[Symbol.asyncIterator] = function () { - return streamToAsyncIterator(this); -}; + return streamToAsyncIterator(this); +} Readable.prototype.iterator = function (options) { - if (options !== undefined) { - validateObject(options, "options", options); - } - return streamToAsyncIterator(this, options); -}; + if (options !== undefined) { + validateObject(options, 'options', options); + } + return streamToAsyncIterator(this, options); +} function streamToAsyncIterator(stream, options) { - if (typeof stream.read !== "function") { - stream = Readable.wrap(stream, { - objectMode: true, - }); - } - const iter = createAsyncIterator(stream, options); - iter.stream = stream; - return iter; + if (typeof stream.read !== 'function') { + stream = Readable.wrap(stream, { + objectMode: true + }); + } + const iter = createAsyncIterator(stream, options); + iter.stream = stream; + return iter; } async function* createAsyncIterator(stream, options) { - let callback = nop; - function next(resolve) { - if (this === stream) { - callback(); - callback = nop; - } else { - callback = resolve; - } - } - stream.on("readable", next); - let error; - const cleanup = eos( - stream, - { - writable: false, - }, - (err) => { - error = err ? aggregateTwoErrors(error, err) : null; - callback(); - callback = nop; - } - ); - try { - while (true) { - const chunk = stream.destroyed ? null : stream.read(); - if (chunk !== null) { - yield chunk; - } else if (error) { - throw error; - } else if (error === null) { - return; - } else { - await new Promise(next); - } - } - } catch (err) { - error = aggregateTwoErrors(error, err); + let callback = nop; + function next(resolve) { + if (this === stream) { + callback(); + callback = nop; + } else { + callback = resolve; + } + } + stream.on('readable', next); + let error; + const cleanup = eos( + stream, + { + writable: false + }, + (err) => { + error = err ? aggregateTwoErrors(error, err) : null + callback() + callback = nop + } + ); + try { + while (true) { + const chunk = stream.destroyed ? null : stream.read(); + if (chunk !== null) { + yield chunk; + } else if (error) { throw error; - } finally { - if ( - (error || - (options === null || options === undefined - ? undefined - : options.destroyOnReturn) !== false) && - (error === undefined || stream._readableState.autoDestroy) - ) { - destroyer(stream, null); - } else { - stream.off("readable", next); - cleanup(); - } + } else if (error === null) { + return; + } else { + await new Promise(next); + } + } + } catch (err) { + error = aggregateTwoErrors(error, err); + throw error; + } finally { + if ( + (error || (options === null || options === undefined ? undefined : options.destroyOnReturn) !== false) && + (error === undefined || stream._readableState.autoDestroy) + ) { + destroyer(stream, null); + } else { + stream.off('readable', next); + cleanup(); } + } } // Making it explicit these properties are not enumerable // because otherwise some prototype manipulation in // userland will fail. Object.defineProperties(Readable.prototype, { - readable: { - get() { - const r = this._readableState; - // r.readable === false means that this is part of a Duplex stream - // where the readable side was disabled upon construction. - // Compat. The user might manually disable readable side through - // deprecated setter. - return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted && !r.endEmitted; - }, - set(val) { - // Backwards compat. - if (this._readableState) { - this._readableState.readable = !!val; - } - }, - }, - readableDidRead: { - enumerable: false, - get: function () { - return !!this._readableState?.dataEmitted; - }, + readable: { + get() { + const r = this._readableState; + // r.readable === false means that this is part of a Duplex stream + // where the readable side was disabled upon construction. + // Compat. The user might manually disable readable side through + // deprecated setter. + return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted && !r.endEmitted; }, - readableAborted: { - enumerable: false, - get: function () { - return !!( - this._readableState?.readable !== false && - (this._readableState?.destroyed || this._readableState?.errored) && - !this._readableState?.endEmitted - ); - }, + set(val) { + // Backwards compat. + if (this._readableState) { + this._readableState.readable = !!val; + } + } + }, + readableDidRead: { + enumerable: false, + get: function () { + return !!(this._readableState?.dataEmitted); + } + }, + readableAborted: { + enumerable: false, + get: function () { + return !!( + this._readableState?.readable !== false && + (this._readableState?.destroyed || this._readableState?.errored) && + !this._readableState?.endEmitted + ); + } + }, + readableHighWaterMark: { + enumerable: false, + get: function () { + return this._readableState?.highWaterMark; + } + }, + readableBuffer: { + enumerable: false, + get: function () { + return this._readableState?.buffer; + } + }, + readableFlowing: { + enumerable: false, + get: function () { + return !!(this._readableState?.flowing); }, - readableHighWaterMark: { - enumerable: false, - get: function () { - return this._readableState?.highWaterMark; - }, - }, - readableBuffer: { - enumerable: false, - get: function () { - return this._readableState?.buffer; - }, - }, - readableFlowing: { - enumerable: false, - get: function () { - return !!this._readableState?.flowing; - }, - set: function (state) { - if (this._readableState) { - this._readableState.flowing = state; - } - }, - }, - readableLength: { - enumerable: false, - get() { - return this._readableState?.length | 0; - }, - }, - readableObjectMode: { - enumerable: false, - get() { - return this._readableState ? this._readableState.objectMode : false; - }, - }, - readableEncoding: { - enumerable: false, - get() { - return this._readableState?.encoding || null; - }, - }, - errored: { - enumerable: false, - get() { - return this._readableState?.errored || null; - }, - }, - closed: { - get() { - return !!this._readableState?.closed; - }, - }, - destroyed: { - enumerable: false, - get() { - return !!this._readableState?.destroyed; - }, - set(value) { - // We ignore the value if the stream - // has not been initialized yet. - if (!this._readableState) { - return; - } - - // Backward compatibility, the user is explicitly - // managing destroyed. - this._readableState.destroyed = value; - }, - }, - readableEnded: { - enumerable: false, - get() { - return !!this._readableState?.endEmitted; - }, + set: function (state) { + if (this._readableState) { + this._readableState.flowing = state + } + } + }, + readableLength: { + enumerable: false, + get() { + return this._readableState?.length | 0; + } + }, + readableObjectMode: { + enumerable: false, + get() { + return this._readableState ? this._readableState.objectMode : false; + } + }, + readableEncoding: { + enumerable: false, + get() { + return this._readableState?.encoding || null; + } + }, + errored: { + enumerable: false, + get() { + return this._readableState?.errored || null; + } + }, + closed: { + get() { + return !!(this._readableState?.closed); + } + }, + destroyed: { + enumerable: false, + get() { + return !!(this._readableState?.destroyed); }, + set(value) { + // We ignore the value if the stream + // has not been initialized yet. + if (!this._readableState) { + return + } + + // Backward compatibility, the user is explicitly + // managing destroyed. + this._readableState.destroyed = value + } + }, + readableEnded: { + enumerable: false, + get() { + return !!(this._readableState?.endEmitted); + } + } }); Object.defineProperties(ReadableState.prototype, { - // Legacy getter for `pipesCount`. - pipesCount: { - get() { - return this.pipes.length; - }, - }, - // Legacy property for `paused`. - paused: { - get() { - return this[kPaused] !== false; - }, - set(value) { - this[kPaused] = !!value; - }, + // Legacy getter for `pipesCount`. + pipesCount: { + get() { + return this.pipes.length + } + }, + // Legacy property for `paused`. + paused: { + get() { + return this[kPaused] !== false }, + set(value) { + this[kPaused] = !!value + } + } }); // Exposed for testing purposes only. -Readable._fromList = fromList; +Readable._fromList = fromList // Pluck off n bytes from an array of buffers. // Length is the combined lengths of all the buffers in the list. // This function is designed to be inlinable, so please take care when making // changes to the function body. function fromList(n, state) { - // nothing buffered. - if (state.length === 0) return null; - let ret; - if (state.objectMode) ret = state.buffer.shift(); - else if (!n || n >= state.length) { - // Read it all, truncate the list. - if (state.decoder) ret = state.buffer.join(""); - else if (state.buffer.length === 1) ret = state.buffer.first(); - else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list. - ret = state.buffer.consume(n, !!state.decoder); - } - return ret; + // nothing buffered. + if (state.length === 0) return null + let ret + if (state.objectMode) ret = state.buffer.shift() + else if (!n || n >= state.length) { + // Read it all, truncate the list. + if (state.decoder) ret = state.buffer.join('') + else if (state.buffer.length === 1) ret = state.buffer.first(); + else ret = state.buffer.concat(state.length); + state.buffer.clear() + } else { + // read part of list. + ret = state.buffer.consume(n, !!state.decoder); + } + return ret } function endReadable(stream) { - const state = stream._readableState; - if (!state.endEmitted) { - state.ended = true; - process.nextTick(endReadableNT, state, stream); - } + const state = stream._readableState + if (!state.endEmitted) { + state.ended = true; + process.nextTick(endReadableNT, state, stream); + } } function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.errored && !state.closeEmitted && !state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.emit("end"); - if (stream.writable && stream.allowHalfOpen === false) { - process.nextTick(endWritableNT, stream); - } else if (state.autoDestroy) { - // In case of duplex streams we need a way to detect - // if the writable side is ready for autoDestroy as well. - const wState = stream._writableState; - const autoDestroy = - !wState || - (wState.autoDestroy && - // We don't expect the writable to ever 'finish' - // if writable is explicitly set to false. - (wState.finished || wState.writable === false)); - if (autoDestroy) { - stream.destroy(); - } - } - } + // Check that we didn't get one last unshift. + if (!state.errored && !state.closeEmitted && !state.endEmitted && state.length === 0) { + state.endEmitted = true + stream.emit('end') + if (stream.writable && stream.allowHalfOpen === false) { + process.nextTick(endWritableNT, stream); + } else if (state.autoDestroy) { + // In case of duplex streams we need a way to detect + // if the writable side is ready for autoDestroy as well. + const wState = stream._writableState + const autoDestroy = + !wState || + (wState.autoDestroy && + // We don't expect the writable to ever 'finish' + // if writable is explicitly set to false. + (wState.finished || wState.writable === false)) + if (autoDestroy) { + stream.destroy() + } + } + } } function endWritableNT(stream) { - const writable = stream.writable && !stream.writableEnded && !stream.destroyed; - if (writable) { - stream.end(); - } + const writable = stream.writable && !stream.writableEnded && !stream.destroyed + if (writable) { + stream.end() + } } Readable.fromWeb = function (readableStream, options) { - return newStreamReadableFromReadableStream(readableStream, options); -}; + return newStreamReadableFromReadableStream(readableStream, options) +} Readable.toWeb = function (streamReadable, options) { - return newReadableStreamFromStreamReadable(streamReadable, options); -}; + return newReadableStreamFromStreamReadable(streamReadable, options) +} Readable.wrap = function (src, options) { - let _ref, _src$readableObjectMo; - return new Readable({ - objectMode: - (_ref = - (_src$readableObjectMo = src.readableObjectMode) !== null && - _src$readableObjectMo !== undefined - ? _src$readableObjectMo - : src.objectMode) !== null && _ref !== undefined - ? _ref - : true, - ...options, - destroy(err, callback) { - destroyer(src, err); - callback(err); - }, - }).wrap(src); + let _ref, _src$readableObjectMo; + return new Readable({ + objectMode: + (_ref = + (_src$readableObjectMo = src.readableObjectMode) !== null && _src$readableObjectMo !== undefined + ? _src$readableObjectMo + : src.objectMode) !== null && _ref !== undefined + ? _ref + : true, + ...options, + destroy(err, callback) { + destroyer(src, err) + callback(err) + } + }).wrap(src); }; // ====================================================================================== // Readable.from = function (iterable, opts) { - return from(Readable, iterable, opts); + return from(Readable, iterable, opts) }; export function from(Readable, iterable, opts) { - let iterator; - if (typeof iterable === "string" || iterable instanceof Buffer) { - return new Readable({ - objectMode: true, - ...opts, - read() { - this.push(iterable); - this.push(null); - }, - }); - } - let isAsync; - if (iterable && iterable[Symbol.asyncIterator]) { - isAsync = true; - iterator = iterable[Symbol.asyncIterator](); - } else if (iterable && iterable[Symbol.iterator]) { - isAsync = false; - iterator = iterable[Symbol.iterator](); - } else { - throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable); - } - const readable = new Readable({ - objectMode: true, - highWaterMark: 1, - // TODO(ronag): What options should be allowed? - ...opts, - }); - - // Flag to protect against _read - // being called before last iteration completion. - let reading = false; - readable._read = function () { - if (!reading) { - reading = true; - next(); - } - }; - readable._destroy = function (error, cb) { - close(error).then( - () => process.nextTick(cb, error), - (err) => process.nextTick(cb, err || error) - ); - }; - async function close(error) { - const hadError = error !== undefined && error !== null; - const hasThrow = typeof iterator.throw === "function"; - if (hadError && hasThrow) { - const { value, done } = await iterator.throw(error); - await value; - if (done) { - return; - } - } - if (typeof iterator.return === "function") { - const { value } = await iterator.return(); - await value; - } - } - async function next() { - for (;;) { - try { - const { value, done } = isAsync ? await iterator.next() : iterator.next(); - if (done) { - readable.push(null); - } else { - const res = value && typeof value.then === "function" ? await value : value; - if (res === null) { - reading = false; - throw new ERR_STREAM_NULL_VALUES(); - } else if (readable.push(res)) { - continue; - } else { - reading = false; - } - } - } catch (err) { - readable.destroy(err); - } - break; + let iterator; + if (typeof iterable === 'string' || iterable instanceof Buffer) { + return new Readable({ + objectMode: true, + ...opts, + read() { + this.push(iterable) + this.push(null) + } + }) + } + let isAsync; + if (iterable && iterable[Symbol.asyncIterator]) { + isAsync = true + iterator = iterable[Symbol.asyncIterator]() + } else if (iterable && iterable[Symbol.iterator]) { + isAsync = false + iterator = iterable[Symbol.iterator]() + } else { + throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable) + } + const readable = new Readable({ + objectMode: true, + highWaterMark: 1, + // TODO(ronag): What options should be allowed? + ...opts + }) + + // Flag to protect against _read + // being called before last iteration completion. + let reading = false + readable._read = function () { + if (!reading) { + reading = true + next() + } + } + readable._destroy = function (error, cb) { + close(error).then( + () => process.nextTick(cb, error), + (err) => process.nextTick(cb, err || error)); + } + async function close(error) { + const hadError = error !== undefined && error !== null + const hasThrow = typeof iterator.throw === 'function' + if (hadError && hasThrow) { + const { value, done } = await iterator.throw(error) + await value + if (done) { + return + } + } + if (typeof iterator.return === 'function') { + const { value } = await iterator.return() + await value + } + } + async function next() { + for (;;) { + try { + const { value, done } = isAsync ? await iterator.next() : iterator.next() + if (done) { + readable.push(null) + } else { + const res = value && typeof value.then === 'function' ? await value : value + if (res === null) { + reading = false + throw new ERR_STREAM_NULL_VALUES() + } else if (readable.push(res)) { + continue + } else { + reading = false + } } + } catch (err) { + readable.destroy(err) + } + break } - return readable; + } + return readable } // ====================================================================================== // Operators -const kWeakHandler = Symbol("kWeak"); -const kEmpty = Symbol("kEmpty"); -const kEof = Symbol("kEof"); +const kWeakHandler = Symbol('kWeak') +const kEmpty = Symbol('kEmpty') +const kEof = Symbol('kEof') function map(fn, options) { - if (typeof fn !== "function") { - throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn); - } - if (options != null) { - validateObject(options, "options", options); - } - if (options?.signal != null) { - validateAbortSignal(options.signal, "options.signal"); - } - let concurrency = 1; - if (options?.concurrency != null) { - concurrency = Math.floor(options.concurrency); - } - validateInteger(concurrency, "concurrency", 1); - return async function* map() { - let _options$signal, _options$signal2; - const ac = new AbortController(); - const stream = this; - const queue = []; - const signal = ac.signal; - const signalOpt = { - signal, - }; - const abort = () => ac.abort(); - if ( - options !== null && - options !== undefined && - (_options$signal = options.signal) !== null && - _options$signal !== undefined && - _options$signal.aborted - ) { - abort(); - } - options === null || options === undefined - ? undefined - : (_options$signal2 = options.signal) === null || _options$signal2 === undefined - ? undefined - : _options$signal2.addEventListener("abort", abort); - let next; - let resume; - let done = false; - function onDone() { - done = true; + if (typeof fn !== 'function') { + throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn) + } + if (options != null) { + validateObject(options, 'options', options); + } + if (options?.signal != null) { + validateAbortSignal(options.signal, 'options.signal'); + } + let concurrency = 1; + if (options?.concurrency != null) { + concurrency = Math.floor(options.concurrency); + } + validateInteger(concurrency, 'concurrency', 1); + return async function* map() { + let _options$signal, _options$signal2; + const ac = new AbortController(); + const stream = this; + const queue = []; + const signal = ac.signal; + const signalOpt = { + signal + }; + const abort = () => ac.abort(); + if ( + options !== null && + options !== undefined && + (_options$signal = options.signal) !== null && + _options$signal !== undefined && + _options$signal.aborted + ) { + abort(); + } + options === null || options === undefined + ? undefined + : (_options$signal2 = options.signal) === null || _options$signal2 === undefined + ? undefined + : _options$signal2.addEventListener('abort', abort); + let next; + let resume; + let done = false; + function onDone() { + done = true; + } + async function pump() { + try { + for await (let val of stream) { + let _val; + if (done) { + return; + } + if (signal.aborted) { + throw new AbortError(); + } + try { + val = fn(val, signalOpt); + } catch (err) { + val = Promise.reject(err); + } + if (val === kEmpty) { + continue; + } + if (typeof ((_val = val) === null || _val === undefined ? undefined : _val.catch) === 'function') { + val.catch(onDone); + } + queue.push(val); + if (next) { + next(); + next = null; + } + if (!done && queue.length && queue.length >= concurrency) { + await new Promise((resolve) => { + resume = resolve; + }); + } } - async function pump() { - try { - for await (let val of stream) { - let _val; - if (done) { - return; - } - if (signal.aborted) { - throw new AbortError(); - } - try { - val = fn(val, signalOpt); - } catch (err) { - val = Promise.reject(err); - } - if (val === kEmpty) { - continue; - } - if ( - typeof ((_val = val) === null || _val === undefined - ? undefined - : _val.catch) === "function" - ) { - val.catch(onDone); - } - queue.push(val); - if (next) { - next(); - next = null; - } - if (!done && queue.length && queue.length >= concurrency) { - await new Promise((resolve) => { - resume = resolve; - }); - } - } - queue.push(kEof); - } catch (err) { - const val = Promise.reject(err); - val.then(undefined, onDone); - queue.push(val); - } finally { - let _options$signal3; - done = true; - if (next) { - next(); - next = null; - } - options === null || options === undefined - ? undefined - : (_options$signal3 = options.signal) === null || _options$signal3 === undefined - ? undefined - : _options$signal3.removeEventListener("abort", abort); - } + queue.push(kEof); + } catch (err) { + const val = Promise.reject(err); + val.then(undefined, onDone);; + queue.push(val); + } finally { + let _options$signal3; + done = true; + if (next) { + next(); + next = null; } - pump(); - try { - while (true) { - while (queue.length > 0) { - const val = await queue[0]; - if (val === kEof) { - return; - } - if (signal.aborted) { - throw new AbortError(); - } - if (val !== kEmpty) { - yield val; - } - queue.shift(); - if (resume) { - resume(); - resume = null; - } - } - await new Promise((resolve) => { - next = resolve; - }); - } - } finally { - ac.abort(); - done = true; - if (resume) { - resume(); - resume = null; - } + options === null || options === undefined + ? undefined + : (_options$signal3 = options.signal) === null || _options$signal3 === undefined + ? undefined + : _options$signal3.removeEventListener('abort', abort); + } + } + pump(); + try { + while (true) { + while (queue.length > 0) { + const val = await queue[0]; + if (val === kEof) { + return; + } + if (signal.aborted) { + throw new AbortError(); + } + if (val !== kEmpty) { + yield val; + } + queue.shift() + if (resume) { + resume(); + resume = null; + } } - }.call(this); + await new Promise((resolve) => { + next = resolve + }); + } + } finally { + ac.abort(); + done = true; + if (resume) { + resume(); + resume = null; + } + } + }.call(this); } function asIndexedPairs(options) { - if (options != null) { - validateObject(options, "options", options); - } - if ((options === null || options === undefined ? undefined : options.signal) != null) { - validateAbortSignal(options.signal, "options.signal"); + if (options != null) { + validateObject(options, 'options', options); + } + if ((options === null || options === undefined ? undefined : options.signal) != null) { + validateAbortSignal(options.signal, 'options.signal'); + } + return async function* asIndexedPairs() { + let index = 0; + for await (const val of this) { + let _options$signal4; + if ( + options !== null && + options !== undefined && + (_options$signal4 = options.signal) !== null && + _options$signal4 !== undefined && + _options$signal4.aborted + ) { + throw new AbortError('Aborted', { + cause: options.signal?.reason + }); + } + yield [index++, val]; } - return async function* asIndexedPairs() { - let index = 0; - for await (const val of this) { - let _options$signal4; - if ( - options !== null && - options !== undefined && - (_options$signal4 = options.signal) !== null && - _options$signal4 !== undefined && - _options$signal4.aborted - ) { - throw new AbortError("Aborted", { - cause: options.signal?.reason, - }); - } - yield [index++, val]; - } - }.call(this); + }.call(this); } async function some(fn, options) { - if (typeof fn !== "function") { - throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn); - } - for await (const _ of filter.call(this, fn, options)) { - return true; - } - return false; + if (typeof fn !== 'function') { + throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn); + } + for await (const _ of filter.call(this, fn, options)) { + return true; + } + return false; } async function every(fn, options) { - if (typeof fn !== "function") { - throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn); - } - // https://en.wikipedia.org/wiki/De_Morgan%27s_laws - return !(await some.call( - this, - async (...args) => { - return !(await fn(...args)); - }, - options - )); + if (typeof fn !== 'function') { + throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn); + } + // https://en.wikipedia.org/wiki/De_Morgan%27s_laws + return !(await some.call( + this, + async (...args) => { + return !(await fn(...args)) + }, + options + )); } async function find(fn, options) { - for await (const result of filter.call(this, fn, options)) { - return result; - } - return undefined; + for await (const result of filter.call(this, fn, options)) { + return result; + } + return undefined; } async function forEach(fn, options) { - if (typeof fn !== "function") { - throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn); - } - async function forEachFn(value, options) { - await fn(value, options); - return kEmpty; - } - // eslint-disable-next-line no-unused-vars - for await (const _ of map.call(this, forEachFn, options)); + if (typeof fn !== 'function') { + throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn) + } + async function forEachFn(value, options) { + await fn(value, options); + return kEmpty + } + // eslint-disable-next-line no-unused-vars + for await (const _ of map.call(this, forEachFn, options)); } function filter(fn, options) { - if (typeof fn !== "function") { - throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn); - } - async function filterFn(value, options) { - if (await fn(value, options)) { - return value; - } - return kEmpty; - } - return map.call(this, filterFn, options); + if (typeof fn !== 'function') { + throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn) + } + async function filterFn(value, options) { + if (await fn(value, options)) { + return value + } + return kEmpty + } + return map.call(this, filterFn, options) } // Specific to provide better error to reduce since the argument is only // missing if the stream has no items in it - but the code is still appropriate class ReduceAwareErrMissingArgs extends ERR_MISSING_ARGS { - constructor() { - super("reduce"); - this.message = "Reduce of an empty stream requires an initial value"; - } + constructor() { + super('reduce') + this.message = 'Reduce of an empty stream requires an initial value' + } } async function reduce(reducer, initialValue, options) { - let _options$signal5; - if (typeof reducer !== "function") { - throw new ERR_INVALID_ARG_TYPE("reducer", ["Function", "AsyncFunction"], reducer); - } - if (options != null) { - validateObject(options, "options", options); - } - if (options?.signal != null) { - validateAbortSignal(options?.signal, "options.signal"); - } - let hasInitialValue = arguments.length > 1; - if ( + let _options$signal5; + if (typeof reducer !== 'function') { + throw new ERR_INVALID_ARG_TYPE('reducer', ['Function', 'AsyncFunction'], reducer); + } + if (options != null) { + validateObject(options, 'options', options); + } + if (options?.signal != null) { + validateAbortSignal(options?.signal, 'options.signal'); + } + let hasInitialValue = arguments.length > 1; + if ( + options !== null && + options !== undefined && + (_options$signal5 = options.signal) !== null && + _options$signal5 !== undefined && + _options$signal5.aborted + ) { + const err = new AbortError(undefined, { + cause: options.signal?.reason + }) + this.once('error', () => {}); // The error is already propagated + await finished(this.destroy(err)); + throw err; + } + const ac = new AbortController(); + const signal = ac.signal; + if (options?.signal) { + const opts = { + once: true, + [kWeakHandler]: this + }; + options.signal.addEventListener('abort', () => ac.abort(), opts); + } + let gotAnyItemFromStream = false; + try { + for await (const value of this) { + let _options$signal6; + gotAnyItemFromStream = true; + if ( options !== null && options !== undefined && - (_options$signal5 = options.signal) !== null && - _options$signal5 !== undefined && - _options$signal5.aborted - ) { - const err = new AbortError(undefined, { - cause: options.signal?.reason, + (_options$signal6 = options.signal) !== null && + _options$signal6 !== undefined && + _options$signal6.aborted + ) { + throw new AbortError(); + } + if (!hasInitialValue) { + initialValue = value; + hasInitialValue = true; + } else { + initialValue = await reducer(initialValue, value, { + signal }); - this.once("error", () => {}); // The error is already propagated - await finished(this.destroy(err)); - throw err; - } - const ac = new AbortController(); - const signal = ac.signal; - if (options?.signal) { - const opts = { - once: true, - [kWeakHandler]: this, - }; - options.signal.addEventListener("abort", () => ac.abort(), opts); + } } - let gotAnyItemFromStream = false; - try { - for await (const value of this) { - let _options$signal6; - gotAnyItemFromStream = true; - if ( - options !== null && - options !== undefined && - (_options$signal6 = options.signal) !== null && - _options$signal6 !== undefined && - _options$signal6.aborted - ) { - throw new AbortError(); - } - if (!hasInitialValue) { - initialValue = value; - hasInitialValue = true; - } else { - initialValue = await reducer(initialValue, value, { - signal, - }); - } - } - if (!gotAnyItemFromStream && !hasInitialValue) { - throw new ReduceAwareErrMissingArgs(); - } - } finally { - ac.abort(); + if (!gotAnyItemFromStream && !hasInitialValue) { + throw new ReduceAwareErrMissingArgs(); } - return initialValue; + } finally { + ac.abort(); + } + return initialValue; } async function toArray(options) { - if (options != null) { - validateObject(options, "options", options); - } - if (options?.signal != null) { - validateAbortSignal(options?.signal, "options.signal"); - } - const result = []; - for await (const val of this) { - let _options$signal7; - if ( - options !== null && - options !== undefined && - (_options$signal7 = options.signal) !== null && - _options$signal7 !== undefined && - _options$signal7.aborted - ) { - throw new AbortError(undefined, { - cause: options.signal?.reason, - }); - } - result.push(val); + if (options != null) { + validateObject(options, 'options', options); + } + if (options?.signal != null) { + validateAbortSignal(options?.signal, 'options.signal') + } + const result = []; + for await (const val of this) { + let _options$signal7; + if ( + options !== null && + options !== undefined && + (_options$signal7 = options.signal) !== null && + _options$signal7 !== undefined && + _options$signal7.aborted + ) { + throw new AbortError(undefined, { + cause: options.signal?.reason + }); } - return result; + result.push(val); + } + return result; } function flatMap(fn, options) { - const values = map.call(this, fn, options); - return async function* flatMap() { - for await (const val of values) { - yield* val; - } - }.call(this); + const values = map.call(this, fn, options) + return async function* flatMap() { + for await (const val of values) { + yield* val + } + }.call(this) } function toIntegerOrInfinity(number) { - // We coerce here to align with the spec - // https://github.com/tc39/proposal-iterator-helpers/issues/169 - number = Number(number); - if (Number.isNaN(number)) { - return 0; - } - if (number < 0) { - throw new ERR_OUT_OF_RANGE("number", ">= 0", number); - } - return number; + // We coerce here to align with the spec + // https://github.com/tc39/proposal-iterator-helpers/issues/169 + number = Number(number) + if (Number.isNaN(number)) { + return 0 + } + if (number < 0) { + throw new ERR_OUT_OF_RANGE('number', '>= 0', number) + } + return number } function drop(number, options) { - if (options != null) { - validateObject(options, "options", options); - } - if (options?.signal != null) { - validateAbortSignal(options?.signal, "options.signal"); + if (options != null) { + validateObject(options, 'options', options); + } + if (options?.signal != null) { + validateAbortSignal(options?.signal, 'options.signal'); + } + number = toIntegerOrInfinity(number); + return async function* drop() { + let _options$signal8; + if ( + options !== null && + options !== undefined && + (_options$signal8 = options.signal) !== null && + _options$signal8 !== undefined && + _options$signal8.aborted + ) { + throw new AbortError(); } - number = toIntegerOrInfinity(number); - return async function* drop() { - let _options$signal8; - if ( - options !== null && - options !== undefined && - (_options$signal8 = options.signal) !== null && - _options$signal8 !== undefined && - _options$signal8.aborted - ) { - throw new AbortError(); - } - for await (const val of this) { - let _options$signal9; - if ( - options !== null && - options !== undefined && - (_options$signal9 = options.signal) !== null && - _options$signal9 !== undefined && - _options$signal9.aborted - ) { - throw new AbortError(); - } - if (number-- <= 0) { - yield val; - } - } - }.call(this); + for await (const val of this) { + let _options$signal9; + if ( + options !== null && + options !== undefined && + (_options$signal9 = options.signal) !== null && + _options$signal9 !== undefined && + _options$signal9.aborted + ) { + throw new AbortError(); + } + if (number-- <= 0) { + yield val; + } + } + }.call(this); } function take(number, options) { - if (options != null) { - validateObject(options, "options", options); - } - if (options?.signal != null) { - validateAbortSignal(options?.signal, "options.signal"); + if (options != null) { + validateObject(options, 'options', options); + } + if (options?.signal != null) { + validateAbortSignal(options?.signal, 'options.signal'); + } + number = toIntegerOrInfinity(number); + return async function* take() { + let _options$signal10; + if ( + options !== null && + options !== undefined && + (_options$signal10 = options.signal) !== null && + _options$signal10 !== undefined && + _options$signal10.aborted + ) { + throw new AbortError(); } - number = toIntegerOrInfinity(number); - return async function* take() { - let _options$signal10; - if ( - options !== null && - options !== undefined && - (_options$signal10 = options.signal) !== null && - _options$signal10 !== undefined && - _options$signal10.aborted - ) { - throw new AbortError(); - } - for await (const val of this) { - let _options$signal11; - if ( - options !== null && - options !== undefined && - (_options$signal11 = options.signal) !== null && - _options$signal11 !== undefined && - _options$signal11.aborted - ) { - throw new AbortError(); - } - if (number-- > 0) { - yield val; - } else { - return; - } - } - }.call(this); + for await (const val of this) { + let _options$signal11; + if ( + options !== null && + options !== undefined && + (_options$signal11 = options.signal) !== null && + _options$signal11 !== undefined && + _options$signal11.aborted + ) { + throw new AbortError(); + } + if (number-- > 0) { + yield val; + } else { + return; + } + } + }.call(this); } -Readable.prototype.map = function (fn, options) { - return from(Readable, map.call(this, fn, options)); -}; +Readable.prototype.map = function(fn, options) { + return from(Readable, map.call(this, fn, options)); +} -Readable.prototype.asIndexedPairs = function (options) { - return from(Readable, asIndexedPairs.call(this, options)); -}; +Readable.prototype.asIndexedPairs = function(options) { + return from(Readable, asIndexedPairs.call(this, options)); +} -Readable.prototype.drop = function (number, options) { - return from(Readable, drop.call(this, number, options)); -}; +Readable.prototype.drop = function(number, options) { + return from(Readable, drop.call(this, number, options)); +} -Readable.prototype.filter = function (fn, options) { - return from(Readable, filter.call(this, fn, options)); -}; +Readable.prototype.filter = function(fn, options) { + return from(Readable, filter.call(this, fn, options)); +} -Readable.prototype.flatMap = function (fn, options) { - return from(Readable, flatMap.call(this, fn, options)); +Readable.prototype.flatMap = function(fn, options) { + return from(Readable, flatMap.call(this, fn, options)); }; -Readable.prototype.take = function (number, options) { - return from(Readable, take.call(this, number, options)); -}; +Readable.prototype.take = function(number, options) { + return from(Readable, take.call(this, number, options)); +} Readable.prototype.every = every; Readable.prototype.forEach = forEach; @@ -1765,3 +1754,4 @@ Readable.prototype.reduce = reduce; Readable.prototype.toArray = toArray; Readable.prototype.some = some; Readable.prototype.find = find; + diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.d.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.d.ts index 7add11339..127ce7887 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.d.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.d.ts @@ -1,392 +1,344 @@ -import EventEmitter from "./events"; +import EventEmitter from './events'; interface WritableOptions { - highWaterMark?: number | undefined; - decodeStrings?: boolean | undefined; - defaultEncoding?: BufferEncoding | undefined; - objectMode?: boolean | undefined; - emitClose?: boolean | undefined; - write?( - this: Writable, - chunk: any, - encoding: BufferEncoding, - callback: (error?: Error | null) => void - ): void; - writev?( - this: Writable, - chunks: Array<{ chunk: any; encoding: BufferEncoding }>, - callback: (error?: Error | null) => void - ): void; - destroy?(this: Writable, error: Error | null, callback: (error: Error | null) => void): void; - final?(this: Writable, callback: (error?: Error | null) => void): void; - autoDestroy?: boolean | undefined; + highWaterMark?: number | undefined; + decodeStrings?: boolean | undefined; + defaultEncoding?: BufferEncoding | undefined; + objectMode?: boolean | undefined; + emitClose?: boolean | undefined; + write?(this: Writable, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; + writev?(this: Writable, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void; + destroy?(this: Writable, error: Error | null, callback: (error: Error | null) => void): void; + final?(this: Writable, callback: (error?: Error | null) => void): void; + autoDestroy?: boolean | undefined; } export class internal extends EventEmitter { - pipe( - destination: T, - options?: { end?: boolean | undefined } - ): T; + pipe(destination: T, options?: { end?: boolean | undefined; }): T; } export class Stream extends internal { - constructor(opts?: ReadableOptions); + constructor(opts?: ReadableOptions); } interface ReadableOptions { - highWaterMark?: number | undefined; - encoding?: BufferEncoding | undefined; - objectMode?: boolean | undefined; - read?(this: Readable, size: number): void; - destroy?(this: Readable, error: Error | null, callback: (error: Error | null) => void): void; - autoDestroy?: boolean | undefined; + highWaterMark?: number | undefined; + encoding?: BufferEncoding | undefined; + objectMode?: boolean | undefined; + read?(this: Readable, size: number): void; + destroy?(this: Readable, error: Error | null, callback: (error: Error | null) => void): void; + autoDestroy?: boolean | undefined; } export class Readable extends Stream implements NodeJS.ReadableStream { - static from(iterable: Iterable | AsyncIterable, options?: ReadableOptions): Readable; + static from(iterable: Iterable | AsyncIterable, options?: ReadableOptions): Readable; - readable: boolean; - readonly readableEncoding: BufferEncoding | null; - readonly readableEnded: boolean; - readonly readableFlowing: boolean | null; - readonly readableHighWaterMark: number; - readonly readableLength: number; - readonly readableObjectMode: boolean; - destroyed: boolean; - constructor(opts?: ReadableOptions); - _read(size: number): void; - read(size?: number): any; - setEncoding(encoding: BufferEncoding): this; - pause(): this; - resume(): this; - isPaused(): boolean; - unpipe(destination?: NodeJS.WritableStream): this; - unshift(chunk: any, encoding?: BufferEncoding): void; - wrap(oldStream: NodeJS.ReadableStream): this; - push(chunk: any, encoding?: BufferEncoding): boolean; - _destroy(error: Error | null, callback: (error?: Error | null) => void): void; - destroy(error?: Error): this; + readable: boolean; + readonly readableEncoding: BufferEncoding | null; + readonly readableEnded: boolean; + readonly readableFlowing: boolean | null; + readonly readableHighWaterMark: number; + readonly readableLength: number; + readonly readableObjectMode: boolean; + destroyed: boolean; + constructor(opts?: ReadableOptions); + _read(size: number): void; + read(size?: number): any; + setEncoding(encoding: BufferEncoding): this; + pause(): this; + resume(): this; + isPaused(): boolean; + unpipe(destination?: NodeJS.WritableStream): this; + unshift(chunk: any, encoding?: BufferEncoding): void; + wrap(oldStream: NodeJS.ReadableStream): this; + push(chunk: any, encoding?: BufferEncoding): boolean; + _destroy(error: Error | null, callback: (error?: Error | null) => void): void; + destroy(error?: Error): this; - addListener(event: "close", listener: () => void): this; - addListener(event: "data", listener: (chunk: any) => void): this; - addListener(event: "end", listener: () => void): this; - addListener(event: "error", listener: (err: Error) => void): this; - addListener(event: "pause", listener: () => void): this; - addListener(event: "readable", listener: () => void): this; - addListener(event: "resume", listener: () => void): this; - addListener(event: string | symbol, listener: (...args: any[]) => void): this; + addListener(event: "close", listener: () => void): this; + addListener(event: "data", listener: (chunk: any) => void): this; + addListener(event: "end", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "pause", listener: () => void): this; + addListener(event: "readable", listener: () => void): this; + addListener(event: "resume", listener: () => void): this; + addListener(event: string | symbol, listener: (...args: any[]) => void): this; - emit(event: "close"): boolean; - emit(event: "data", chunk: any): boolean; - emit(event: "end"): boolean; - emit(event: "error", err: Error): boolean; - emit(event: "pause"): boolean; - emit(event: "readable"): boolean; - emit(event: "resume"): boolean; - emit(event: string | symbol, ...args: any[]): boolean; + emit(event: "close"): boolean; + emit(event: "data", chunk: any): boolean; + emit(event: "end"): boolean; + emit(event: "error", err: Error): boolean; + emit(event: "pause"): boolean; + emit(event: "readable"): boolean; + emit(event: "resume"): boolean; + emit(event: string | symbol, ...args: any[]): boolean; - on(event: "close", listener: () => void): this; - on(event: "data", listener: (chunk: any) => void): this; - on(event: "end", listener: () => void): this; - on(event: "error", listener: (err: Error) => void): this; - on(event: "pause", listener: () => void): this; - on(event: "readable", listener: () => void): this; - on(event: "resume", listener: () => void): this; - on(event: string | symbol, listener: (...args: any[]) => void): this; + on(event: "close", listener: () => void): this; + on(event: "data", listener: (chunk: any) => void): this; + on(event: "end", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "pause", listener: () => void): this; + on(event: "readable", listener: () => void): this; + on(event: "resume", listener: () => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; - once(event: "close", listener: () => void): this; - once(event: "data", listener: (chunk: any) => void): this; - once(event: "end", listener: () => void): this; - once(event: "error", listener: (err: Error) => void): this; - once(event: "pause", listener: () => void): this; - once(event: "readable", listener: () => void): this; - once(event: "resume", listener: () => void): this; - once(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: "close", listener: () => void): this; + once(event: "data", listener: (chunk: any) => void): this; + once(event: "end", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "pause", listener: () => void): this; + once(event: "readable", listener: () => void): this; + once(event: "resume", listener: () => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; - prependListener(event: "close", listener: () => void): this; - prependListener(event: "data", listener: (chunk: any) => void): this; - prependListener(event: "end", listener: () => void): this; - prependListener(event: "error", listener: (err: Error) => void): this; - prependListener(event: "pause", listener: () => void): this; - prependListener(event: "readable", listener: () => void): this; - prependListener(event: "resume", listener: () => void): this; - prependListener(event: string | symbol, listener: (...args: any[]) => void): this; + prependListener(event: "close", listener: () => void): this; + prependListener(event: "data", listener: (chunk: any) => void): this; + prependListener(event: "end", listener: () => void): this; + prependListener(event: "error", listener: (err: Error) => void): this; + prependListener(event: "pause", listener: () => void): this; + prependListener(event: "readable", listener: () => void): this; + prependListener(event: "resume", listener: () => void): this; + prependListener(event: string | symbol, listener: (...args: any[]) => void): this; - prependOnceListener(event: "close", listener: () => void): this; - prependOnceListener(event: "data", listener: (chunk: any) => void): this; - prependOnceListener(event: "end", listener: () => void): this; - prependOnceListener(event: "error", listener: (err: Error) => void): this; - prependOnceListener(event: "pause", listener: () => void): this; - prependOnceListener(event: "readable", listener: () => void): this; - prependOnceListener(event: "resume", listener: () => void): this; - prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; + prependOnceListener(event: "close", listener: () => void): this; + prependOnceListener(event: "data", listener: (chunk: any) => void): this; + prependOnceListener(event: "end", listener: () => void): this; + prependOnceListener(event: "error", listener: (err: Error) => void): this; + prependOnceListener(event: "pause", listener: () => void): this; + prependOnceListener(event: "readable", listener: () => void): this; + prependOnceListener(event: "resume", listener: () => void): this; + prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; - removeListener(event: "close", listener: () => void): this; - removeListener(event: "data", listener: (chunk: any) => void): this; - removeListener(event: "end", listener: () => void): this; - removeListener(event: "error", listener: (err: Error) => void): this; - removeListener(event: "pause", listener: () => void): this; - removeListener(event: "readable", listener: () => void): this; - removeListener(event: "resume", listener: () => void): this; - removeListener(event: string | symbol, listener: (...args: any[]) => void): this; + removeListener(event: "close", listener: () => void): this; + removeListener(event: "data", listener: (chunk: any) => void): this; + removeListener(event: "end", listener: () => void): this; + removeListener(event: "error", listener: (err: Error) => void): this; + removeListener(event: "pause", listener: () => void): this; + removeListener(event: "readable", listener: () => void): this; + removeListener(event: "resume", listener: () => void): this; + removeListener(event: string | symbol, listener: (...args: any[]) => void): this; - [Symbol.asyncIterator](): AsyncIterableIterator; + [Symbol.asyncIterator](): AsyncIterableIterator; } export class Writable extends Stream implements NodeJS.WritableStream { - readonly writable: boolean; - readonly writableEnded: boolean; - readonly writableFinished: boolean; - readonly writableHighWaterMark: number; - readonly writableLength: number; - readonly writableObjectMode: boolean; - readonly writableCorked: number; - destroyed: boolean; - constructor(opts?: WritableOptions); - _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; - _writev?( - chunks: Array<{ chunk: any; encoding: BufferEncoding }>, - callback: (error?: Error | null) => void - ): void; - _destroy(error: Error | null, callback: (error?: Error | null) => void): void; - _final(callback: (error?: Error | null) => void): void; - write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean; - write( - chunk: any, - encoding: BufferEncoding, - cb?: (error: Error | null | undefined) => void - ): boolean; - setDefaultEncoding(encoding: BufferEncoding): this; - end(cb?: () => void): this; - end(chunk: any, cb?: () => void): this; - end(chunk: any, encoding: BufferEncoding, cb?: () => void): this; - cork(): void; - uncork(): void; - destroy(error?: Error): this; + readonly writable: boolean; + readonly writableEnded: boolean; + readonly writableFinished: boolean; + readonly writableHighWaterMark: number; + readonly writableLength: number; + readonly writableObjectMode: boolean; + readonly writableCorked: number; + destroyed: boolean; + constructor(opts?: WritableOptions); + _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; + _writev?(chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void; + _destroy(error: Error | null, callback: (error?: Error | null) => void): void; + _final(callback: (error?: Error | null) => void): void; + write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean; + write(chunk: any, encoding: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean; + setDefaultEncoding(encoding: BufferEncoding): this; + end(cb?: () => void): this; + end(chunk: any, cb?: () => void): this; + end(chunk: any, encoding: BufferEncoding, cb?: () => void): this; + cork(): void; + uncork(): void; + destroy(error?: Error): this; - addListener(event: "close", listener: () => void): this; - addListener(event: "drain", listener: () => void): this; - addListener(event: "error", listener: (err: Error) => void): this; - addListener(event: "finish", listener: () => void): this; - addListener(event: "pipe", listener: (src: Readable) => void): this; - addListener(event: "unpipe", listener: (src: Readable) => void): this; - addListener(event: string | symbol, listener: (...args: any[]) => void): this; + addListener(event: "close", listener: () => void): this; + addListener(event: "drain", listener: () => void): this; + addListener(event: "error", listener: (err: Error) => void): this; + addListener(event: "finish", listener: () => void): this; + addListener(event: "pipe", listener: (src: Readable) => void): this; + addListener(event: "unpipe", listener: (src: Readable) => void): this; + addListener(event: string | symbol, listener: (...args: any[]) => void): this; - emit(event: "close"): boolean; - emit(event: "drain"): boolean; - emit(event: "error", err: Error): boolean; - emit(event: "finish"): boolean; - emit(event: "pipe", src: Readable): boolean; - emit(event: "unpipe", src: Readable): boolean; - emit(event: string | symbol, ...args: any[]): boolean; + emit(event: "close"): boolean; + emit(event: "drain"): boolean; + emit(event: "error", err: Error): boolean; + emit(event: "finish"): boolean; + emit(event: "pipe", src: Readable): boolean; + emit(event: "unpipe", src: Readable): boolean; + emit(event: string | symbol, ...args: any[]): boolean; - on(event: "close", listener: () => void): this; - on(event: "drain", listener: () => void): this; - on(event: "error", listener: (err: Error) => void): this; - on(event: "finish", listener: () => void): this; - on(event: "pipe", listener: (src: Readable) => void): this; - on(event: "unpipe", listener: (src: Readable) => void): this; - on(event: string | symbol, listener: (...args: any[]) => void): this; + on(event: "close", listener: () => void): this; + on(event: "drain", listener: () => void): this; + on(event: "error", listener: (err: Error) => void): this; + on(event: "finish", listener: () => void): this; + on(event: "pipe", listener: (src: Readable) => void): this; + on(event: "unpipe", listener: (src: Readable) => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; - once(event: "close", listener: () => void): this; - once(event: "drain", listener: () => void): this; - once(event: "error", listener: (err: Error) => void): this; - once(event: "finish", listener: () => void): this; - once(event: "pipe", listener: (src: Readable) => void): this; - once(event: "unpipe", listener: (src: Readable) => void): this; - once(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: "close", listener: () => void): this; + once(event: "drain", listener: () => void): this; + once(event: "error", listener: (err: Error) => void): this; + once(event: "finish", listener: () => void): this; + once(event: "pipe", listener: (src: Readable) => void): this; + once(event: "unpipe", listener: (src: Readable) => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; - prependListener(event: "close", listener: () => void): this; - prependListener(event: "drain", listener: () => void): this; - prependListener(event: "error", listener: (err: Error) => void): this; - prependListener(event: "finish", listener: () => void): this; - prependListener(event: "pipe", listener: (src: Readable) => void): this; - prependListener(event: "unpipe", listener: (src: Readable) => void): this; - prependListener(event: string | symbol, listener: (...args: any[]) => void): this; + prependListener(event: "close", listener: () => void): this; + prependListener(event: "drain", listener: () => void): this; + prependListener(event: "error", listener: (err: Error) => void): this; + prependListener(event: "finish", listener: () => void): this; + prependListener(event: "pipe", listener: (src: Readable) => void): this; + prependListener(event: "unpipe", listener: (src: Readable) => void): this; + prependListener(event: string | symbol, listener: (...args: any[]) => void): this; - prependOnceListener(event: "close", listener: () => void): this; - prependOnceListener(event: "drain", listener: () => void): this; - prependOnceListener(event: "error", listener: (err: Error) => void): this; - prependOnceListener(event: "finish", listener: () => void): this; - prependOnceListener(event: "pipe", listener: (src: Readable) => void): this; - prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this; - prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; + prependOnceListener(event: "close", listener: () => void): this; + prependOnceListener(event: "drain", listener: () => void): this; + prependOnceListener(event: "error", listener: (err: Error) => void): this; + prependOnceListener(event: "finish", listener: () => void): this; + prependOnceListener(event: "pipe", listener: (src: Readable) => void): this; + prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this; + prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; - removeListener(event: "close", listener: () => void): this; - removeListener(event: "drain", listener: () => void): this; - removeListener(event: "error", listener: (err: Error) => void): this; - removeListener(event: "finish", listener: () => void): this; - removeListener(event: "pipe", listener: (src: Readable) => void): this; - removeListener(event: "unpipe", listener: (src: Readable) => void): this; - removeListener(event: string | symbol, listener: (...args: any[]) => void): this; + removeListener(event: "close", listener: () => void): this; + removeListener(event: "drain", listener: () => void): this; + removeListener(event: "error", listener: (err: Error) => void): this; + removeListener(event: "finish", listener: () => void): this; + removeListener(event: "pipe", listener: (src: Readable) => void): this; + removeListener(event: "unpipe", listener: (src: Readable) => void): this; + removeListener(event: string | symbol, listener: (...args: any[]) => void): this; } + export class Duplex extends Readable implements Writable { - readonly writable: boolean; - readonly writableEnded: boolean; - readonly writableFinished: boolean; - readonly writableHighWaterMark: number; - readonly writableLength: number; - readonly writableObjectMode: boolean; - readonly writableCorked: number; - allowHalfOpen: boolean; - constructor(opts?: DuplexOptions); - _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; - _writev?( - chunks: Array<{ chunk: any; encoding: BufferEncoding }>, - callback: (error?: Error | null) => void - ): void; - _destroy(error: Error | null, callback: (error: Error | null) => void): void; - _final(callback: (error?: Error | null) => void): void; - write( - chunk: any, - encoding?: BufferEncoding, - cb?: (error: Error | null | undefined) => void - ): boolean; - write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean; - setDefaultEncoding(encoding: BufferEncoding): this; - end(cb?: () => void): this; - end(chunk: any, cb?: () => void): this; - end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this; - cork(): void; - uncork(): void; - addListener(event: "close", listener: () => void): this; - addListener(event: "data", listener: (chunk: any) => void): this; - addListener(event: "drain", listener: () => void): this; - addListener(event: "end", listener: () => void): this; - addListener(event: "error", listener: (err: Error) => void): this; - addListener(event: "finish", listener: () => void): this; - addListener(event: "pause", listener: () => void): this; - addListener(event: "pipe", listener: (src: Readable) => void): this; - addListener(event: "readable", listener: () => void): this; - addListener(event: "resume", listener: () => void): this; - addListener(event: "unpipe", listener: (src: Readable) => void): this; - addListener(event: string | symbol, listener: (...args: any[]) => void): this; - emit(event: "close"): boolean; - emit(event: "data", chunk: any): boolean; - emit(event: "drain"): boolean; - emit(event: "end"): boolean; - emit(event: "error", err: Error): boolean; - emit(event: "finish"): boolean; - emit(event: "pause"): boolean; - emit(event: "pipe", src: Readable): boolean; - emit(event: "readable"): boolean; - emit(event: "resume"): boolean; - emit(event: "unpipe", src: Readable): boolean; - emit(event: string | symbol, ...args: any[]): boolean; - on(event: "close", listener: () => void): this; - on(event: "data", listener: (chunk: any) => void): this; - on(event: "drain", listener: () => void): this; - on(event: "end", listener: () => void): this; - on(event: "error", listener: (err: Error) => void): this; - on(event: "finish", listener: () => void): this; - on(event: "pause", listener: () => void): this; - on(event: "pipe", listener: (src: Readable) => void): this; - on(event: "readable", listener: () => void): this; - on(event: "resume", listener: () => void): this; - on(event: "unpipe", listener: (src: Readable) => void): this; - on(event: string | symbol, listener: (...args: any[]) => void): this; - once(event: "close", listener: () => void): this; - once(event: "data", listener: (chunk: any) => void): this; - once(event: "drain", listener: () => void): this; - once(event: "end", listener: () => void): this; - once(event: "error", listener: (err: Error) => void): this; - once(event: "finish", listener: () => void): this; - once(event: "pause", listener: () => void): this; - once(event: "pipe", listener: (src: Readable) => void): this; - once(event: "readable", listener: () => void): this; - once(event: "resume", listener: () => void): this; - once(event: "unpipe", listener: (src: Readable) => void): this; - once(event: string | symbol, listener: (...args: any[]) => void): this; - prependListener(event: "close", listener: () => void): this; - prependListener(event: "data", listener: (chunk: any) => void): this; - prependListener(event: "drain", listener: () => void): this; - prependListener(event: "end", listener: () => void): this; - prependListener(event: "error", listener: (err: Error) => void): this; - prependListener(event: "finish", listener: () => void): this; - prependListener(event: "pause", listener: () => void): this; - prependListener(event: "pipe", listener: (src: Readable) => void): this; - prependListener(event: "readable", listener: () => void): this; - prependListener(event: "resume", listener: () => void): this; - prependListener(event: "unpipe", listener: (src: Readable) => void): this; - prependListener(event: string | symbol, listener: (...args: any[]) => void): this; - prependOnceListener(event: "close", listener: () => void): this; - prependOnceListener(event: "data", listener: (chunk: any) => void): this; - prependOnceListener(event: "drain", listener: () => void): this; - prependOnceListener(event: "end", listener: () => void): this; - prependOnceListener(event: "error", listener: (err: Error) => void): this; - prependOnceListener(event: "finish", listener: () => void): this; - prependOnceListener(event: "pause", listener: () => void): this; - prependOnceListener(event: "pipe", listener: (src: Readable) => void): this; - prependOnceListener(event: "readable", listener: () => void): this; - prependOnceListener(event: "resume", listener: () => void): this; - prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this; - prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; - removeListener(event: "close", listener: () => void): this; - removeListener(event: "data", listener: (chunk: any) => void): this; - removeListener(event: "drain", listener: () => void): this; - removeListener(event: "end", listener: () => void): this; - removeListener(event: "error", listener: (err: Error) => void): this; - removeListener(event: "finish", listener: () => void): this; - removeListener(event: "pause", listener: () => void): this; - removeListener(event: "pipe", listener: (src: Readable) => void): this; - removeListener(event: "readable", listener: () => void): this; - removeListener(event: "resume", listener: () => void): this; - removeListener(event: "unpipe", listener: (src: Readable) => void): this; - removeListener(event: string | symbol, listener: (...args: any[]) => void): this; + readonly writable: boolean; + readonly writableEnded: boolean; + readonly writableFinished: boolean; + readonly writableHighWaterMark: number; + readonly writableLength: number; + readonly writableObjectMode: boolean; + readonly writableCorked: number; + allowHalfOpen: boolean; + constructor(opts?: DuplexOptions); + _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; + _writev?(chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void; + _destroy(error: Error | null, callback: (error: Error | null) => void): void; + _final(callback: (error?: Error | null) => void): void; + write(chunk: any, encoding?: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean; + write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean; + setDefaultEncoding(encoding: BufferEncoding): this; + end(cb?: () => void): this; + end(chunk: any, cb?: () => void): this; + end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this; + cork(): void; + uncork(): void; + addListener(event: 'close', listener: () => void): this; + addListener(event: 'data', listener: (chunk: any) => void): this; + addListener(event: 'drain', listener: () => void): this; + addListener(event: 'end', listener: () => void): this; + addListener(event: 'error', listener: (err: Error) => void): this; + addListener(event: 'finish', listener: () => void): this; + addListener(event: 'pause', listener: () => void): this; + addListener(event: 'pipe', listener: (src: Readable) => void): this; + addListener(event: 'readable', listener: () => void): this; + addListener(event: 'resume', listener: () => void): this; + addListener(event: 'unpipe', listener: (src: Readable) => void): this; + addListener(event: string | symbol, listener: (...args: any[]) => void): this; + emit(event: 'close'): boolean; + emit(event: 'data', chunk: any): boolean; + emit(event: 'drain'): boolean; + emit(event: 'end'): boolean; + emit(event: 'error', err: Error): boolean; + emit(event: 'finish'): boolean; + emit(event: 'pause'): boolean; + emit(event: 'pipe', src: Readable): boolean; + emit(event: 'readable'): boolean; + emit(event: 'resume'): boolean; + emit(event: 'unpipe', src: Readable): boolean; + emit(event: string | symbol, ...args: any[]): boolean; + on(event: 'close', listener: () => void): this; + on(event: 'data', listener: (chunk: any) => void): this; + on(event: 'drain', listener: () => void): this; + on(event: 'end', listener: () => void): this; + on(event: 'error', listener: (err: Error) => void): this; + on(event: 'finish', listener: () => void): this; + on(event: 'pause', listener: () => void): this; + on(event: 'pipe', listener: (src: Readable) => void): this; + on(event: 'readable', listener: () => void): this; + on(event: 'resume', listener: () => void): this; + on(event: 'unpipe', listener: (src: Readable) => void): this; + on(event: string | symbol, listener: (...args: any[]) => void): this; + once(event: 'close', listener: () => void): this; + once(event: 'data', listener: (chunk: any) => void): this; + once(event: 'drain', listener: () => void): this; + once(event: 'end', listener: () => void): this; + once(event: 'error', listener: (err: Error) => void): this; + once(event: 'finish', listener: () => void): this; + once(event: 'pause', listener: () => void): this; + once(event: 'pipe', listener: (src: Readable) => void): this; + once(event: 'readable', listener: () => void): this; + once(event: 'resume', listener: () => void): this; + once(event: 'unpipe', listener: (src: Readable) => void): this; + once(event: string | symbol, listener: (...args: any[]) => void): this; + prependListener(event: 'close', listener: () => void): this; + prependListener(event: 'data', listener: (chunk: any) => void): this; + prependListener(event: 'drain', listener: () => void): this; + prependListener(event: 'end', listener: () => void): this; + prependListener(event: 'error', listener: (err: Error) => void): this; + prependListener(event: 'finish', listener: () => void): this; + prependListener(event: 'pause', listener: () => void): this; + prependListener(event: 'pipe', listener: (src: Readable) => void): this; + prependListener(event: 'readable', listener: () => void): this; + prependListener(event: 'resume', listener: () => void): this; + prependListener(event: 'unpipe', listener: (src: Readable) => void): this; + prependListener(event: string | symbol, listener: (...args: any[]) => void): this; + prependOnceListener(event: 'close', listener: () => void): this; + prependOnceListener(event: 'data', listener: (chunk: any) => void): this; + prependOnceListener(event: 'drain', listener: () => void): this; + prependOnceListener(event: 'end', listener: () => void): this; + prependOnceListener(event: 'error', listener: (err: Error) => void): this; + prependOnceListener(event: 'finish', listener: () => void): this; + prependOnceListener(event: 'pause', listener: () => void): this; + prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this; + prependOnceListener(event: 'readable', listener: () => void): this; + prependOnceListener(event: 'resume', listener: () => void): this; + prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this; + prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this; + removeListener(event: 'close', listener: () => void): this; + removeListener(event: 'data', listener: (chunk: any) => void): this; + removeListener(event: 'drain', listener: () => void): this; + removeListener(event: 'end', listener: () => void): this; + removeListener(event: 'error', listener: (err: Error) => void): this; + removeListener(event: 'finish', listener: () => void): this; + removeListener(event: 'pause', listener: () => void): this; + removeListener(event: 'pipe', listener: (src: Readable) => void): this; + removeListener(event: 'readable', listener: () => void): this; + removeListener(event: 'resume', listener: () => void): this; + removeListener(event: 'unpipe', listener: (src: Readable) => void): this; + removeListener(event: string | symbol, listener: (...args: any[]) => void): this; } interface DuplexOptions extends ReadableOptions, WritableOptions { - allowHalfOpen?: boolean | undefined; - readableObjectMode?: boolean | undefined; - writableObjectMode?: boolean | undefined; - readableHighWaterMark?: number | undefined; - writableHighWaterMark?: number | undefined; - writableCorked?: number | undefined; - read?(this: Duplex, size: number): void; - write?( - this: Duplex, - chunk: any, - encoding: BufferEncoding, - callback: (error?: Error | null) => void - ): void; - writev?( - this: Duplex, - chunks: Array<{ chunk: any; encoding: BufferEncoding }>, - callback: (error?: Error | null) => void - ): void; - final?(this: Duplex, callback: (error?: Error | null) => void): void; - destroy?(this: Duplex, error: Error | null, callback: (error: Error | null) => void): void; + allowHalfOpen?: boolean | undefined; + readableObjectMode?: boolean | undefined; + writableObjectMode?: boolean | undefined; + readableHighWaterMark?: number | undefined; + writableHighWaterMark?: number | undefined; + writableCorked?: number | undefined; + read?(this: Duplex, size: number): void; + write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; + writev?(this: Duplex, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void; + final?(this: Duplex, callback: (error?: Error | null) => void): void; + destroy?(this: Duplex, error: Error | null, callback: (error: Error | null) => void): void; } interface TransformOptions extends DuplexOptions { - read?(this: Transform, size: number): void; - write?( - this: Transform, - chunk: any, - encoding: BufferEncoding, - callback: (error?: Error | null) => void - ): void; - writev?( - this: Transform, - chunks: Array<{ chunk: any; encoding: BufferEncoding }>, - callback: (error?: Error | null) => void - ): void; - final?(this: Transform, callback: (error?: Error | null) => void): void; - destroy?(this: Transform, error: Error | null, callback: (error: Error | null) => void): void; - transform?( - this: Transform, - chunk: any, - encoding: BufferEncoding, - callback: TransformCallback - ): void; - flush?(this: Transform, callback: TransformCallback): void; + read?(this: Transform, size: number): void; + write?(this: Transform, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void; + writev?(this: Transform, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void; + final?(this: Transform, callback: (error?: Error | null) => void): void; + destroy?(this: Transform, error: Error | null, callback: (error: Error | null) => void): void; + transform?(this: Transform, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void; + flush?(this: Transform, callback: TransformCallback): void; } type TransformCallback = (error?: Error | null, data?: any) => void; export class Transform extends Duplex { - constructor(opts?: TransformOptions); - _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void; - _flush(callback: TransformCallback): void; + constructor(opts?: TransformOptions); + _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void; + _flush(callback: TransformCallback): void; } diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.js index 213c21c61..3abb6ddca 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_transform.js @@ -1,143 +1,147 @@ -"use strict"; +'use strict' -import { ERR_METHOD_NOT_IMPLEMENTED } from "./internal_errors"; +import { + ERR_METHOD_NOT_IMPLEMENTED +} from './internal_errors'; -import { Duplex } from "./streams_duplex"; +import { + Duplex, +} from './streams_duplex'; -import { getHighWaterMark } from "./streams_util"; +import { + getHighWaterMark, +} from './streams_util'; Object.setPrototypeOf(Transform.prototype, Duplex.prototype); Object.setPrototypeOf(Transform, Duplex); -const kCallback = Symbol("kCallback"); +const kCallback = Symbol('kCallback'); export function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - // TODO (ronag): This should preferably always be - // applied but would be semver-major. Or even better; - // make Transform a Readable with the Writable interface. - const readableHighWaterMark = options - ? getHighWaterMark(options, "readableHighWaterMark", true) - : null; - if (readableHighWaterMark === 0) { - // A Duplex will buffer both on the writable and readable side while - // a Transform just wants to buffer hwm number of elements. To avoid - // buffering twice we disable buffering on the writable side. - options = { - ...options, - highWaterMark: null, - readableHighWaterMark, - // TODO (ronag): 0 is not optimal since we have - // a "bug" where we check needDrain before calling _write and not after. - // Refs: https://github.com/nodejs/node/pull/32887 - // Refs: https://github.com/nodejs/node/pull/35941 - writableHighWaterMark: options?.writableHighWaterMark || 0, - }; - } - Duplex.call(this, options); - - // We have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - this[kCallback] = null; - if (options) { - if (typeof options.transform === "function") this._transform = options.transform; - if (typeof options.flush === "function") this._flush = options.flush; - } - - // When the writable side finishes, then flush out anything remaining. - // Backwards compat. Some Transform streams incorrectly implement _final - // instead of or in addition to _flush. By using 'prefinish' instead of - // implementing _final we continue supporting this unfortunate use case. - this.on("prefinish", prefinish); + if (!(this instanceof Transform)) return new Transform(options); + + // TODO (ronag): This should preferably always be + // applied but would be semver-major. Or even better; + // make Transform a Readable with the Writable interface. + const readableHighWaterMark = options ? getHighWaterMark(options, 'readableHighWaterMark', true) : null; + if (readableHighWaterMark === 0) { + // A Duplex will buffer both on the writable and readable side while + // a Transform just wants to buffer hwm number of elements. To avoid + // buffering twice we disable buffering on the writable side. + options = { + ...options, + highWaterMark: null, + readableHighWaterMark, + // TODO (ronag): 0 is not optimal since we have + // a "bug" where we check needDrain before calling _write and not after. + // Refs: https://github.com/nodejs/node/pull/32887 + // Refs: https://github.com/nodejs/node/pull/35941 + writableHighWaterMark: options?.writableHighWaterMark || 0 + }; + } + Duplex.call(this, options); + + // We have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + this[kCallback] = null; + if (options) { + if (typeof options.transform === 'function') this._transform = options.transform; + if (typeof options.flush === 'function') this._flush = options.flush; + } + + // When the writable side finishes, then flush out anything remaining. + // Backwards compat. Some Transform streams incorrectly implement _final + // instead of or in addition to _flush. By using 'prefinish' instead of + // implementing _final we continue supporting this unfortunate use case. + this.on('prefinish', prefinish); } function final(cb) { - if (typeof this._flush === "function" && !this.destroyed) { - this._flush((er, data) => { - if (er) { - if (cb) { - cb(er); - } else { - this.destroy(er); - } - return; - } - if (data != null) { - this.push(data); - } - this.push(null); - if (cb) { - cb(); - } - }); - } else { - this.push(null); + if (typeof this._flush === 'function' && !this.destroyed) { + this._flush((er, data) => { + if (er) { if (cb) { - cb(); + cb(er); + } else { + this.destroy(er); } + return; + } + if (data != null) { + this.push(data); + } + this.push(null); + if (cb) { + cb(); + } + }) + } else { + this.push(null); + if (cb) { + cb(); } + } } function prefinish() { - if (this._final !== final) { - final.call(this); - } + if (this._final !== final) { + final.call(this); + } } Transform.prototype._final = final; Transform.prototype._transform = function () { - throw new ERR_METHOD_NOT_IMPLEMENTED("_transform()"); -}; + throw new ERR_METHOD_NOT_IMPLEMENTED('_transform()') +} Transform.prototype._write = function (chunk, encoding, callback) { - const rState = this._readableState; - const wState = this._writableState; - const length = rState.length; - this._transform(chunk, encoding, (err, val) => { - if (err) { - callback(err); - return; - } - if (val != null) { - this.push(val); - } - if ( - wState.ended || - // Backwards compat. - length === rState.length || - // Backwards compat. - rState.length < rState.highWaterMark - ) { - callback(); - } else { - this[kCallback] = callback; - } - }); -}; + const rState = this._readableState; + const wState = this._writableState; + const length = rState.length; + this._transform(chunk, encoding, (err, val) => { + if (err) { + callback(err); + return; + } + if (val != null) { + this.push(val); + } + if ( + wState.ended || + // Backwards compat. + length === rState.length || + // Backwards compat. + rState.length < rState.highWaterMark + ) { + callback(); + } else { + this[kCallback] = callback; + } + }) +} Transform.prototype._read = function (_size) { - if (this[kCallback]) { - const callback = this[kCallback]; - this[kCallback] = null; - callback(); - } -}; + if (this[kCallback]) { + const callback = this[kCallback]; + this[kCallback] = null; + callback(); + } +} Object.setPrototypeOf(PassThrough.prototype, Transform.prototype); Object.setPrototypeOf(PassThrough, Transform); export function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - Transform.call(this, { - ...options, - transform: undefined, - flush: undefined, - }); + if (!(this instanceof PassThrough)) return new PassThrough(options); + Transform.call(this, { + ...options, + transform: undefined, + flush: undefined, + }); } PassThrough.prototype._transform = function (chunk, _, cb) { - cb(null, chunk); -}; + cb(null, chunk); +} diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_util.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_util.js index 91949bd71..e9c50973b 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_util.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_util.js @@ -1,767 +1,723 @@ -export const kDestroyed = Symbol("kDestroyed"); -export const kIsErrored = Symbol("kIsErrored"); -export const kIsReadable = Symbol("kIsReadable"); -export const kIsDisturbed = Symbol("kIsDisturbed"); -export const kPaused = Symbol("kPaused"); -export const kOnFinished = Symbol("kOnFinished"); -export const kDestroy = Symbol("kDestroy"); -export const kConstruct = Symbol("kConstruct"); +export const kDestroyed = Symbol('kDestroyed'); +export const kIsErrored = Symbol('kIsErrored'); +export const kIsReadable = Symbol('kIsReadable'); +export const kIsDisturbed = Symbol('kIsDisturbed'); +export const kPaused = Symbol('kPaused'); +export const kOnFinished = Symbol('kOnFinished'); +export const kDestroy = Symbol('kDestroy'); +export const kConstruct = Symbol('kConstruct'); import { - AbortError, - ERR_INVALID_ARG_TYPE, - ERR_INVALID_ARG_VALUE, - ERR_STREAM_PREMATURE_CLOSE, - ERR_MULTIPLE_CALLBACK, - aggregateTwoErrors, -} from "./internal_errors"; + AbortError, + ERR_INVALID_ARG_TYPE, + ERR_INVALID_ARG_VALUE, + ERR_STREAM_PREMATURE_CLOSE, + ERR_MULTIPLE_CALLBACK, + aggregateTwoErrors, +} from './internal_errors'; -import * as process from "./process"; +import * as process from './process'; -import { Buffer } from "./internal_buffer"; +import { Buffer } from './internal_buffer'; -import { validateAbortSignal, validateFunction, validateObject } from "./validators"; +import { + validateAbortSignal, + validateFunction, + validateObject, +} from './validators'; export function isReadableNodeStream(obj, strict = false) { - let _obj$_readableState; - return !!( - ( - obj && - typeof obj.pipe === "function" && - typeof obj.on === "function" && - (!strict || (typeof obj.pause === "function" && typeof obj.resume === "function")) && - (!obj._writableState || - ((_obj$_readableState = obj._readableState) === null || - _obj$_readableState === undefined - ? undefined - : _obj$_readableState.readable) !== false) && - // Duplex - (!obj._writableState || obj._readableState) - ) // Writable has .pipe. - ); + let _obj$_readableState; + return !!( + ( + obj && + typeof obj.pipe === 'function' && + typeof obj.on === 'function' && + (!strict || (typeof obj.pause === 'function' && + typeof obj.resume === 'function')) && + (!obj._writableState || + ((_obj$_readableState = obj._readableState) === null || + _obj$_readableState === undefined ? undefined + : _obj$_readableState.readable) !== false) && + // Duplex + (!obj._writableState || obj._readableState) + ) // Writable has .pipe. + ); } export function isWritableNodeStream(obj) { - let _obj$_writableState; - return !!( - ( - obj && - typeof obj.write === "function" && - typeof obj.on === "function" && - (!obj._readableState || - ((_obj$_writableState = obj._writableState) === null || - _obj$_writableState === undefined - ? undefined - : _obj$_writableState.writable) !== false) - ) // Duplex - ); + let _obj$_writableState; + return !!( + ( + obj && + typeof obj.write === 'function' && + typeof obj.on === 'function' && + (!obj._readableState || + ((_obj$_writableState = obj._writableState) === null || + _obj$_writableState === undefined ? undefined + : _obj$_writableState.writable) !== false) + ) // Duplex + ); } export function isDuplexNodeStream(obj) { - return !!( - obj && - typeof obj.pipe === "function" && - obj._readableState && - typeof obj.on === "function" && - typeof obj.write === "function" - ); + return !!( + obj && + typeof obj.pipe === 'function' && + obj._readableState && + typeof obj.on === 'function' && + typeof obj.write === 'function' + ); } export function isNodeStream(obj) { - return ( - obj && - (obj._readableState || - obj._writableState || - (typeof obj.write === "function" && typeof obj.on === "function") || - (typeof obj.pipe === "function" && typeof obj.on === "function")) - ); + return ( + obj && + (obj._readableState || + obj._writableState || + (typeof obj.write === 'function' && + typeof obj.on === 'function') || + (typeof obj.pipe === 'function' && + typeof obj.on === 'function')) + ); } export function isIterable(obj, isAsync = false) { - if (obj == null) return false; - if (isAsync === true) return typeof obj[Symbol.asyncIterator] === "function"; - if (isAsync === false) return typeof obj[Symbol.iterator] === "function"; - return ( - typeof obj[Symbol.asyncIterator] === "function" || - typeof obj[Symbol.iterator] === "function" - ); + if (obj == null) return false; + if (isAsync === true) return typeof obj[Symbol.asyncIterator] === 'function'; + if (isAsync === false) return typeof obj[Symbol.iterator] === 'function'; + return typeof obj[Symbol.asyncIterator] === 'function' || + typeof obj[Symbol.iterator] === 'function'; } export function isDestroyed(stream) { - if (!isNodeStream(stream)) return null; - const wState = stream._writableState; - const rState = stream._readableState; - const state = wState || rState; - return !!( - stream.destroyed || - stream[kDestroyed] || - (state !== null && state !== undefined && state.destroyed) - ); + if (!isNodeStream(stream)) return null; + const wState = stream._writableState; + const rState = stream._readableState; + const state = wState || rState; + return !!(stream.destroyed || stream[kDestroyed] || (state !== null && state !== undefined && state.destroyed)); } export function isWritableEnded(stream) { - if (!isWritableNodeStream(stream)) return null; - if (stream.writableEnded === true) return true; - const wState = stream._writableState; - if (wState !== null && wState !== undefined && wState.errored) return false; - if (typeof (wState === null || wState === undefined ? undefined : wState.ended) !== "boolean") - return null; - return wState.ended; + if (!isWritableNodeStream(stream)) return null; + if (stream.writableEnded === true) return true; + const wState = stream._writableState; + if (wState !== null && wState !== undefined && wState.errored) return false; + if (typeof (wState === null || wState === undefined ? undefined : wState.ended) !== 'boolean') return null; + return wState.ended; } export function isWritableFinished(stream, strict = false) { - if (!isWritableNodeStream(stream)) return null; - if (stream.writableFinished === true) return true; - const wState = stream._writableState; - if (wState !== null && wState !== undefined && wState.errored) return false; - if ( - typeof (wState === null || wState === undefined ? undefined : wState.finished) !== "boolean" - ) - return null; - return !!( - wState.finished || - (strict === false && wState.ended === true && wState.length === 0) - ); + if (!isWritableNodeStream(stream)) return null; + if (stream.writableFinished === true) return true; + const wState = stream._writableState; + if (wState !== null && wState !== undefined && wState.errored) return false; + if (typeof (wState === null || wState === undefined ? undefined : wState.finished) !== 'boolean') return null; + return !!(wState.finished || (strict === false && wState.ended === true && wState.length === 0)); } export function isReadableEnded(stream) { - if (!isReadableNodeStream(stream)) return null; - if (stream.readableEnded === true) return true; - const rState = stream._readableState; - if (!rState || rState.errored) return false; - if (typeof (rState === null || rState === undefined ? undefined : rState.ended) !== "boolean") - return null; - return rState.ended; + if (!isReadableNodeStream(stream)) return null; + if (stream.readableEnded === true) return true; + const rState = stream._readableState; + if (!rState || rState.errored) return false; + if (typeof (rState === null || rState === undefined ? undefined : rState.ended) !== 'boolean') return null; + return rState.ended; } export function isReadableFinished(stream, strict = false) { - if (!isReadableNodeStream(stream)) return null; - const rState = stream._readableState; - if (rState !== null && rState !== undefined && rState.errored) return false; - if ( - typeof (rState === null || rState === undefined ? undefined : rState.endEmitted) !== - "boolean" - ) - return null; - return !!( - rState.endEmitted || - (strict === false && rState.ended === true && rState.length === 0) - ); + if (!isReadableNodeStream(stream)) return null; + const rState = stream._readableState; + if (rState !== null && rState !== undefined && rState.errored) return false; + if (typeof (rState === null || rState === undefined ? undefined : rState.endEmitted) !== 'boolean') return null; + return !!(rState.endEmitted || (strict === false && rState.ended === true && rState.length === 0)); } export function isReadable(stream) { - if (stream && stream[kIsReadable] != null) return stream[kIsReadable]; - if ( - typeof (stream === null || stream === undefined ? undefined : stream.readable) !== "boolean" - ) - return null; - if (isDestroyed(stream)) return false; - return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream); + if (stream && stream[kIsReadable] != null) return stream[kIsReadable]; + if (typeof (stream === null || stream === undefined ? undefined : stream.readable) !== 'boolean') return null; + if (isDestroyed(stream)) return false; + return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream); } export function isWritable(stream) { - if ( - typeof (stream === null || stream === undefined ? undefined : stream.writable) !== "boolean" - ) - return null; - if (isDestroyed(stream)) return false; - return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream); + if (typeof (stream === null || stream === undefined ? undefined : stream.writable) !== 'boolean') return null; + if (isDestroyed(stream)) return false; + return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream); } export function isFinished(stream, opts = {}) { - if (!isNodeStream(stream)) { - return null; - } - if (isDestroyed(stream)) { - return true; - } - if ( - (opts === null || opts === undefined ? undefined : opts.readable) !== false && - isReadable(stream) - ) { - return false; - } - if ( - (opts === null || opts === undefined ? undefined : opts.writable) !== false && - isWritable(stream) - ) { - return false; - } + if (!isNodeStream(stream)) { + return null; + } + if (isDestroyed(stream)) { return true; + } + if ((opts === null || opts === undefined ? undefined : opts.readable) !== false && + isReadable(stream)) { + return false; + } + if ((opts === null || opts === undefined ? undefined : opts.writable) !== false && + isWritable(stream)) { + return false; + } + return true; } export function isWritableErrored(stream) { - let _stream$_writableStat, _stream$_writableStat2; - if (!isNodeStream(stream)) { - return null; - } - if (stream.writableErrored) { - return stream.writableErrored; - } - return (_stream$_writableStat = - (_stream$_writableStat2 = stream._writableState) === null || - _stream$_writableStat2 === undefined - ? undefined - : _stream$_writableStat2.errored) !== null && _stream$_writableStat !== undefined - ? _stream$_writableStat - : null; + let _stream$_writableStat, _stream$_writableStat2; + if (!isNodeStream(stream)) { + return null; + } + if (stream.writableErrored) { + return stream.writableErrored; + } + return (_stream$_writableStat = + (_stream$_writableStat2 = stream._writableState) === null || _stream$_writableStat2 === undefined + ? undefined + : _stream$_writableStat2.errored) !== null && _stream$_writableStat !== undefined + ? _stream$_writableStat + : null; } export function isReadableErrored(stream) { - let _stream$_readableStat, _stream$_readableStat2; - if (!isNodeStream(stream)) { - return null; - } - if (stream.readableErrored) { - return stream.readableErrored; - } - return (_stream$_readableStat = - (_stream$_readableStat2 = stream._readableState) === null || - _stream$_readableStat2 === undefined - ? undefined - : _stream$_readableStat2.errored) !== null && _stream$_readableStat !== undefined - ? _stream$_readableStat - : null; + let _stream$_readableStat, _stream$_readableStat2; + if (!isNodeStream(stream)) { + return null; + } + if (stream.readableErrored) { + return stream.readableErrored; + } + return (_stream$_readableStat = + (_stream$_readableStat2 = stream._readableState) === null || _stream$_readableStat2 === undefined + ? undefined + : _stream$_readableStat2.errored) !== null && _stream$_readableStat !== undefined + ? _stream$_readableStat + : null; } export function isClosed(stream) { - if (!isNodeStream(stream)) { - return null; - } - if (typeof stream.closed === "boolean") { - return stream.closed; - } - const wState = stream._writableState; - const rState = stream._readableState; - if ( - typeof (wState === null || wState === undefined ? undefined : wState.closed) === - "boolean" || - typeof (rState === null || rState === undefined ? undefined : rState.closed) === "boolean" - ) { - return ( - (wState === null || wState === undefined ? undefined : wState.closed) || - (rState === null || rState === undefined ? undefined : rState.closed) - ); - } - if (typeof stream._closed === "boolean" && isOutgoingMessage(stream)) { - return stream._closed; - } - return null; + if (!isNodeStream(stream)) { + return null + } + if (typeof stream.closed === 'boolean') { + return stream.closed + } + const wState = stream._writableState + const rState = stream._readableState + if ( + typeof (wState === null || wState === undefined ? undefined : wState.closed) === 'boolean' || + typeof (rState === null || rState === undefined ? undefined : rState.closed) === 'boolean' + ) { + return ( + (wState === null || wState === undefined ? undefined : wState.closed) || + (rState === null || rState === undefined ? undefined : rState.closed) + ) + } + if (typeof stream._closed === 'boolean' && isOutgoingMessage(stream)) { + return stream._closed + } + return null } // TODO(later): We do not actually support OutgoingMessage yet. Might not ever? // Keeping this here tho just to keep things simple. export function isOutgoingMessage(stream) { - return ( - typeof stream._closed === "boolean" && - typeof stream._defaultKeepAlive === "boolean" && - typeof stream._removedConnection === "boolean" && - typeof stream._removedContLen === "boolean" - ); + return ( + typeof stream._closed === 'boolean' && + typeof stream._defaultKeepAlive === 'boolean' && + typeof stream._removedConnection === 'boolean' && + typeof stream._removedContLen === 'boolean' + ); } // TODO(later): We do not actually support Server Response yet. Might not ever? // Keeping this here tho just to keep things simple. export function isServerResponse(stream) { - return typeof stream._sent100 === "boolean" && isOutgoingMessage(stream); + return typeof stream._sent100 === 'boolean' && isOutgoingMessage(stream); } // TODO(later): We do not actually support Server Request yet. Might not ever? // Keeping this here tho just to keep things simple. export function isServerRequest(stream) { - let _stream$req; - return ( - typeof stream._consuming === "boolean" && - typeof stream._dumped === "boolean" && - ((_stream$req = stream.req) === null || _stream$req === undefined - ? undefined - : _stream$req.upgradeOrConnect) === undefined - ); + let _stream$req; + return ( + typeof stream._consuming === 'boolean' && + typeof stream._dumped === 'boolean' && + ((_stream$req = stream.req) === null || _stream$req === undefined ? undefined : _stream$req.upgradeOrConnect) === + undefined + ); } export function willEmitClose(stream) { - if (!isNodeStream(stream)) return null; - const wState = stream._writableState; - const rState = stream._readableState; - const state = wState || rState; - return ( - (!state && isServerResponse(stream)) || - !!(state && state.autoDestroy && state.emitClose && state.closed === false) - ); + if (!isNodeStream(stream)) return null; + const wState = stream._writableState; + const rState = stream._readableState; + const state = wState || rState; + return ( + (!state && isServerResponse(stream)) || !!(state && state.autoDestroy && state.emitClose && state.closed === false) + ); } export function isDisturbed(stream) { - let _stream$kIsDisturbed; - return !!( - stream && - ((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && - _stream$kIsDisturbed !== undefined - ? _stream$kIsDisturbed - : stream.readableDidRead || stream.readableAborted) - ); + let _stream$kIsDisturbed; + return !!( + stream && + ((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && _stream$kIsDisturbed !== undefined + ? _stream$kIsDisturbed + : stream.readableDidRead || stream.readableAborted) + ); } export function isErrored(stream) { - var _ref, - _ref2, - _ref3, - _ref4, - _ref5, - _stream$kIsErrored, - _stream$_readableStat3, - _stream$_writableStat3, - _stream$_readableStat4, - _stream$_writableStat4; - return !!( - stream && - ((_ref = - (_ref2 = - (_ref3 = - (_ref4 = - (_ref5 = - (_stream$kIsErrored = stream[kIsErrored]) !== null && - _stream$kIsErrored !== undefined - ? _stream$kIsErrored - : stream.readableErrored) !== null && _ref5 !== undefined - ? _ref5 - : stream.writableErrored) !== null && _ref4 !== undefined - ? _ref4 - : (_stream$_readableStat3 = stream._readableState) === null || - _stream$_readableStat3 === undefined - ? undefined - : _stream$_readableStat3.errorEmitted) !== null && _ref3 !== undefined - ? _ref3 - : (_stream$_writableStat3 = stream._writableState) === null || - _stream$_writableStat3 === undefined - ? undefined - : _stream$_writableStat3.errorEmitted) !== null && _ref2 !== undefined - ? _ref2 - : (_stream$_readableStat4 = stream._readableState) === null || - _stream$_readableStat4 === undefined - ? undefined - : _stream$_readableStat4.errored) !== null && _ref !== undefined - ? _ref - : (_stream$_writableStat4 = stream._writableState) === null || - _stream$_writableStat4 === undefined - ? undefined - : _stream$_writableStat4.errored) - ); + var _ref, + _ref2, + _ref3, + _ref4, + _ref5, + _stream$kIsErrored, + _stream$_readableStat3, + _stream$_writableStat3, + _stream$_readableStat4, + _stream$_writableStat4 + return !!( + stream && + ((_ref = + (_ref2 = + (_ref3 = + (_ref4 = + (_ref5 = + (_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== undefined + ? _stream$kIsErrored + : stream.readableErrored) !== null && _ref5 !== undefined + ? _ref5 + : stream.writableErrored) !== null && _ref4 !== undefined + ? _ref4 + : (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === undefined + ? undefined + : _stream$_readableStat3.errorEmitted) !== null && _ref3 !== undefined + ? _ref3 + : (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === undefined + ? undefined + : _stream$_writableStat3.errorEmitted) !== null && _ref2 !== undefined + ? _ref2 + : (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === undefined + ? undefined + : _stream$_readableStat4.errored) !== null && _ref !== undefined + ? _ref + : (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === undefined + ? undefined + : _stream$_writableStat4.errored) + ) } export const nop = () => {}; export function once(callback) { - let called = false; - return function (...args) { - if (called) { - return; - } - called = true; - callback.apply(this, args); - }; + let called = false + return function (...args) { + if (called) { + return + } + called = true + callback.apply(this, args) + } } // ====================================================================================== // highWaterMark handling export function highWaterMarkFrom(options, isDuplex, duplexKey) { - return options.highWaterMark != null - ? options.highWaterMark - : isDuplex - ? options[duplexKey] - : null; + return options.highWaterMark != null ? options.highWaterMark : + isDuplex ? options[duplexKey] : null } export function getDefaultHighWaterMark(objectMode = false) { - return objectMode ? 16 : 16 * 1024; + return objectMode ? 16 : 16 * 1024 } export function getHighWaterMark(state, options, duplexKey, isDuplex) { - const hwm = highWaterMarkFrom(options, isDuplex, duplexKey); - if (hwm != null) { - if (!Number.isInteger(hwm) || hwm < 0) { - const name = isDuplex ? `options.${duplexKey}` : "options.highWaterMark"; - throw new ERR_INVALID_ARG_VALUE(name, hwm, name); - } - return Math.floor(hwm); + const hwm = highWaterMarkFrom(options, isDuplex, duplexKey) + if (hwm != null) { + if (!Number.isInteger(hwm) || hwm < 0) { + const name = isDuplex ? `options.${duplexKey}` : 'options.highWaterMark'; + throw new ERR_INVALID_ARG_VALUE(name, hwm, name); } + return Math.floor(hwm); + } - // Default value - return getDefaultHighWaterMark(state.objectMode); + // Default value + return getDefaultHighWaterMark(state.objectMode) } // ====================================================================================== // addAbortSignal export function addAbortSignal(signal, stream) { - validateAbortSignal(signal, "signal"); - if (!isNodeStream(stream)) { - throw new ERR_INVALID_ARG_TYPE("stream", "stream.Stream", stream); - } - const onAbort = () => { - stream.destroy( - new AbortError(undefined, { - cause: signal.reason, - }) - ); - }; - if (signal.aborted) { - onAbort(); - } else { - signal.addEventListener("abort", onAbort); - eos(stream, () => signal.removeEventListener("abort", onAbort)); - } - return stream; + validateAbortSignal(signal, 'signal'); + if (!isNodeStream(stream)) { + throw new ERR_INVALID_ARG_TYPE('stream', 'stream.Stream', stream); + } + const onAbort = () => { + stream.destroy( + new AbortError(undefined, { + cause: signal.reason + }) + ); + } + if (signal.aborted) { + onAbort(); + } else { + signal.addEventListener('abort', onAbort); + eos(stream, () => signal.removeEventListener('abort', onAbort)); + } + return stream; } // ====================================================================================== // BufferList export class BufferList { - head = null; - tail = null; - length = 0; - - push(v) { - const entry = { - data: v, - next: null, - }; - if (this.length > 0) this.tail.next = entry; - else this.head = entry; - this.tail = entry; - ++this.length; - } - unshift(v) { - const entry = { - data: v, - next: this.head, - }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; - } - shift() { - if (this.length === 0) return; - const ret = this.head.data; - if (this.length === 1) this.head = this.tail = null; - else this.head = this.head.next; - --this.length; - return ret; - } - - clear() { - this.head = this.tail = null; - this.length = 0; - } - - join(s) { - if (this.length === 0) return ""; - let p = this.head; - let ret = "" + p.data; - while ((p = p.next) !== null) ret += s + p.data; - return ret; - } - - concat(n) { - if (this.length === 0) return Buffer.alloc(0); - const ret = Buffer.allocUnsafe(n >>> 0); - let p = this.head; - let i = 0; - while (p) { - ret.set(p.data, i); - i += p.data.length; - p = p.next; - } - return ret; - } - - consume(n, hasStrings = false) { - const data = this.head.data; - if (n < data.length) { - // `slice` is the same for buffers and strings. - const slice = data.slice(0, n); - this.head.data = data.slice(n); - return slice; - } - if (n === data.length) { - // First chunk is a perfect match. - return this.shift(); - } - // Result spans more than one buffer. - return hasStrings ? this._getString(n) : this._getBuffer(n); - } - - first() { - return this.head.data; - } - - *[Symbol.iterator]() { - for (let p = this.head; p; p = p.next) { - yield p.data; + head = null; + tail = null; + length = 0; + + push(v) { + const entry = { + data: v, + next: null, + } + if (this.length > 0) this.tail.next = entry; + else this.head = entry; + this.tail = entry; + ++this.length; + } + unshift(v) { + const entry = { + data: v, + next: this.head, + } + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + } + shift() { + if (this.length === 0) return; + const ret = this.head.data; + if (this.length === 1) this.head = this.tail = null; + else this.head = this.head.next; + --this.length; + return ret; + } + + clear() { + this.head = this.tail = null; + this.length = 0; + } + + join(s) { + if (this.length === 0) return ''; + let p = this.head; + let ret = '' + p.data; + while ((p = p.next) !== null) ret += s + p.data; + return ret; + } + + concat(n) { + if (this.length === 0) return Buffer.alloc(0); + const ret = Buffer.allocUnsafe(n >>> 0); + let p = this.head; + let i = 0; + while (p) { + ret.set(p.data, i); + i += p.data.length; + p = p.next; + } + return ret; + } + + consume(n, hasStrings = false) { + const data = this.head.data; + if (n < data.length) { + // `slice` is the same for buffers and strings. + const slice = data.slice(0, n); + this.head.data = data.slice(n); + return slice; + } + if (n === data.length) { + // First chunk is a perfect match. + return this.shift(); + } + // Result spans more than one buffer. + return hasStrings ? this._getString(n) : this._getBuffer(n); + } + + first() { + return this.head.data; + } + + *[Symbol.iterator]() { + for (let p = this.head; p; p = p.next) { + yield p.data; + } + } + + _getString(n) { + let ret = ''; + let p = this.head; + let c = 0; + do { + const str = p.data; + if (n > str.length) { + ret += str; + n -= str.length; + } else { + if (n === str.length) { + ret += str + ++c + if (p.next) this.head = p.next; + else this.head = this.tail = null; + } else { + ret += str.slice(0, n); + this.head = p; + p.data = str.slice(n); + } + break; + } + ++c; + } while ((p = p.next) !== null); + this.length -= c; + return ret; + } + + _getBuffer(n) { + const ret = Buffer.allocUnsafe(n); + const retLen = n; + let p = this.head; + let c = 0; + do { + const buf = p.data; + if (n > buf.length) { + ret.set(buf, retLen - n); + n -= buf.length; + } else { + if (n === buf.length) { + ret.set(buf, retLen - n); + ++c; + if (p.next) this.head = p.next; + else this.head = this.tail = null; + } else { + ret.set(new Uint8Array(buf.buffer, buf.byteOffset, n), retLen - n); + this.head = p; + p.data = buf.slice(n); } - } - - _getString(n) { - let ret = ""; - let p = this.head; - let c = 0; - do { - const str = p.data; - if (n > str.length) { - ret += str; - n -= str.length; - } else { - if (n === str.length) { - ret += str; - ++c; - if (p.next) this.head = p.next; - else this.head = this.tail = null; - } else { - ret += str.slice(0, n); - this.head = p; - p.data = str.slice(n); - } - break; - } - ++c; - } while ((p = p.next) !== null); - this.length -= c; - return ret; - } - - _getBuffer(n) { - const ret = Buffer.allocUnsafe(n); - const retLen = n; - let p = this.head; - let c = 0; - do { - const buf = p.data; - if (n > buf.length) { - ret.set(buf, retLen - n); - n -= buf.length; - } else { - if (n === buf.length) { - ret.set(buf, retLen - n); - ++c; - if (p.next) this.head = p.next; - else this.head = this.tail = null; - } else { - ret.set(new Uint8Array(buf.buffer, buf.byteOffset, n), retLen - n); - this.head = p; - p.data = buf.slice(n); - } - break; - } - ++c; - } while ((p = p.next) !== null); - this.length -= c; - return ret; - } + break; + } + ++c + } while ((p = p.next) !== null); + this.length -= c; + return ret; + } } // ====================================================================================== // TODO(later): We do not current implement Node.js' Request object. Might never? function isRequest(stream) { - return stream && stream.setHeader && typeof stream.abort === "function"; + return stream && stream.setHeader && typeof stream.abort === 'function' } export function eos(stream, options, callback) { - let _options$readable, _options$writable; - if (arguments.length === 2) { - callback = options; - options = {}; - } else if (options == null) { - options = {}; + let _options$readable, _options$writable; + if (arguments.length === 2) { + callback = options; + options = {}; + } else if (options == null) { + options = {}; + } else { + validateObject(options, 'options', options); + } + validateFunction(callback, 'callback'); + validateAbortSignal(options.signal, 'options.signal'); + callback = once(callback); + const readable = + (_options$readable = options.readable) !== null && _options$readable !== undefined + ? _options$readable + : isReadableNodeStream(stream); + const writable = + (_options$writable = options.writable) !== null && _options$writable !== undefined + ? _options$writable + : isWritableNodeStream(stream); + if (!isNodeStream(stream)) { + // TODO: Webstreams. + throw new ERR_INVALID_ARG_TYPE('stream', 'Stream', stream); + } + const wState = stream._writableState; + const rState = stream._readableState; + const onlegacyfinish = () => { + if (!stream.writable) { + onfinish(); + } + }; + + // TODO (ronag): Improve soft detection to include core modules and + // common ecosystem modules that do properly emit 'close' but fail + // this generic check. + let _willEmitClose = + willEmitClose(stream) && isReadableNodeStream(stream) === readable && isWritableNodeStream(stream) === writable; + let writableFinished = isWritableFinished((stream), false); + const onfinish = () => { + writableFinished = true; + // Stream should not be destroyed here. If it is that + // means that user space is doing something differently and + // we cannot trust willEmitClose. + if (stream.destroyed) { + _willEmitClose = false; + } + if (_willEmitClose && (!stream.readable || readable)) { + return; + } + if (!readable || readableFinished) { + callback.call(stream); + } + }; + let readableFinished = isReadableFinished(stream, false); + const onend = () => { + readableFinished = true; + // Stream should not be destroyed here. If it is that + // means that user space is doing something differently and + // we cannot trust willEmitClose. + if (stream.destroyed) { + _willEmitClose = false; + } + if (_willEmitClose && (!stream.writable || writable)) { + return; + } + if (!writable || writableFinished) { + callback.call(stream); + } + }; + const onerror = (err) => { + callback.call(stream, err); + }; + let closed = isClosed(stream); + const onclose = () => { + closed = true; + const errored = isWritableErrored(stream) || isReadableErrored(stream) + if (errored && typeof errored !== 'boolean') { + return callback.call(stream, errored); + } + if (readable && !readableFinished && isReadableNodeStream(stream, true)) { + if (!isReadableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE()); + } + if (writable && !writableFinished) { + if (!isWritableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE()); + } + callback.call(stream); + }; + const onrequest = () => { + stream.req.on('finish', onfinish); + }; + if (isRequest(stream)) { + stream.on('complete', onfinish); + if (!_willEmitClose) { + stream.on('abort', onclose); + } + if (stream.req) { + onrequest(); } else { - validateObject(options, "options", options); - } - validateFunction(callback, "callback"); - validateAbortSignal(options.signal, "options.signal"); - callback = once(callback); - const readable = - (_options$readable = options.readable) !== null && _options$readable !== undefined - ? _options$readable - : isReadableNodeStream(stream); - const writable = - (_options$writable = options.writable) !== null && _options$writable !== undefined - ? _options$writable - : isWritableNodeStream(stream); - if (!isNodeStream(stream)) { - // TODO: Webstreams. - throw new ERR_INVALID_ARG_TYPE("stream", "Stream", stream); - } - const wState = stream._writableState; - const rState = stream._readableState; - const onlegacyfinish = () => { - if (!stream.writable) { - onfinish(); - } - }; - - // TODO (ronag): Improve soft detection to include core modules and - // common ecosystem modules that do properly emit 'close' but fail - // this generic check. - let _willEmitClose = - willEmitClose(stream) && - isReadableNodeStream(stream) === readable && - isWritableNodeStream(stream) === writable; - let writableFinished = isWritableFinished(stream, false); - const onfinish = () => { - writableFinished = true; - // Stream should not be destroyed here. If it is that - // means that user space is doing something differently and - // we cannot trust willEmitClose. - if (stream.destroyed) { - _willEmitClose = false; - } - if (_willEmitClose && (!stream.readable || readable)) { - return; - } - if (!readable || readableFinished) { - callback.call(stream); - } - }; - let readableFinished = isReadableFinished(stream, false); - const onend = () => { - readableFinished = true; - // Stream should not be destroyed here. If it is that - // means that user space is doing something differently and - // we cannot trust willEmitClose. - if (stream.destroyed) { - _willEmitClose = false; - } - if (_willEmitClose && (!stream.writable || writable)) { - return; - } - if (!writable || writableFinished) { - callback.call(stream); - } - }; - const onerror = (err) => { - callback.call(stream, err); - }; - let closed = isClosed(stream); - const onclose = () => { - closed = true; - const errored = isWritableErrored(stream) || isReadableErrored(stream); - if (errored && typeof errored !== "boolean") { - return callback.call(stream, errored); - } - if (readable && !readableFinished && isReadableNodeStream(stream, true)) { - if (!isReadableFinished(stream, false)) - return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE()); - } - if (writable && !writableFinished) { - if (!isWritableFinished(stream, false)) - return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE()); - } - callback.call(stream); - }; - const onrequest = () => { - stream.req.on("finish", onfinish); - }; - if (isRequest(stream)) { - stream.on("complete", onfinish); - if (!_willEmitClose) { - stream.on("abort", onclose); - } - if (stream.req) { - onrequest(); - } else { - stream.on("request", onrequest); - } - } else if (writable && !wState) { - // legacy streams - stream.on("end", onlegacyfinish); - stream.on("close", onlegacyfinish); - } - - // Not all streams will emit 'close' after 'aborted'. - if (!_willEmitClose && typeof stream.aborted === "boolean") { - stream.on("aborted", onclose); - } - stream.on("end", onend); - stream.on("finish", onfinish); - if (options.error !== false) { - stream.on("error", onerror); - } - stream.on("close", onclose); - if (closed) { - process.nextTick(onclose); - } else if ( - (wState !== null && wState !== undefined && wState.errorEmitted) || - (rState !== null && rState !== undefined && rState.errorEmitted) - ) { - if (!_willEmitClose) { - process.nextTick(onclose); - } - } else if ( - !readable && - (!_willEmitClose || isReadable(stream)) && - (writableFinished || isWritable(stream) === false) - ) { - process.nextTick(onclose); - } else if ( - !writable && - (!_willEmitClose || isWritable(stream)) && - (readableFinished || isReadable(stream) === false) - ) { - process.nextTick(onclose); - } else if (rState && stream.req && stream.aborted) { - process.nextTick(onclose); - } - const cleanup = () => { - callback = nop; - stream.removeListener("aborted", onclose); - stream.removeListener("complete", onfinish); - stream.removeListener("abort", onclose); - stream.removeListener("request", onrequest); - if (stream.req) stream.req.removeListener("finish", onfinish); - stream.removeListener("end", onlegacyfinish); - stream.removeListener("close", onlegacyfinish); - stream.removeListener("finish", onfinish); - stream.removeListener("end", onend); - stream.removeListener("error", onerror); - stream.removeListener("close", onclose); - }; - if (options.signal && !closed) { - const abort = () => { - // Keep it because cleanup removes it. - const endCallback = callback; - cleanup(); - endCallback.call( - stream, - new AbortError(undefined, { - cause: options.signal?.reason, - }) - ); - }; - if (options.signal.aborted) { - process.nextTick(abort); - } else { - const originalCallback = callback; - callback = once((...args) => { - options.signal.removeEventListener("abort", abort); - originalCallback.apply(stream, args); - }); - options.signal.addEventListener("abort", abort); - } + stream.on('request', onrequest); + } + } else if (writable && !wState) { + // legacy streams + stream.on('end', onlegacyfinish); + stream.on('close', onlegacyfinish); + } + + // Not all streams will emit 'close' after 'aborted'. + if (!_willEmitClose && typeof stream.aborted === 'boolean') { + stream.on('aborted', onclose); + } + stream.on('end', onend); + stream.on('finish', onfinish); + if (options.error !== false) { + stream.on('error', onerror); + } + stream.on('close', onclose); + if (closed) { + process.nextTick(onclose); + } else if ( + (wState !== null && wState !== undefined && wState.errorEmitted) || + (rState !== null && rState !== undefined && rState.errorEmitted) + ) { + if (!_willEmitClose) { + process.nextTick(onclose); + } + } else if ( + !readable && + (!_willEmitClose || isReadable(stream)) && + (writableFinished || isWritable(stream) === false) + ) { + process.nextTick(onclose); + } else if ( + !writable && + (!_willEmitClose || isWritable(stream)) && + (readableFinished || isReadable(stream) === false) + ) { + process.nextTick(onclose); + } else if (rState && stream.req && stream.aborted) { + process.nextTick(onclose); + } + const cleanup = () => { + callback = nop; + stream.removeListener('aborted', onclose); + stream.removeListener('complete', onfinish); + stream.removeListener('abort', onclose); + stream.removeListener('request', onrequest); + if (stream.req) stream .req.removeListener('finish', onfinish); + stream.removeListener('end', onlegacyfinish); + stream.removeListener('close', onlegacyfinish); + stream.removeListener('finish', onfinish); + stream.removeListener('end', onend); + stream.removeListener('error', onerror); + stream.removeListener('close', onclose); + } + if (options.signal && !closed) { + const abort = () => { + // Keep it because cleanup removes it. + const endCallback = callback + cleanup() + endCallback.call( + stream, + new AbortError(undefined, { + cause: options.signal?.reason + }) + ) + } + if (options.signal.aborted) { + process.nextTick(abort); + } else { + const originalCallback = callback; + callback = once((...args) => { + options.signal.removeEventListener('abort', abort) + originalCallback.apply(stream, args); + }); + options.signal.addEventListener('abort', abort); } - return cleanup; + } + return cleanup; } export function finished(stream, opts) { - return new Promise((resolve, reject) => { - eos(stream, opts, (err) => { - if (err) { - reject(err); - } else { - resolve(); - } - }); - }); + return new Promise((resolve, reject) => { + eos(stream, opts, (err) => { + if (err) { + reject(err); + } else { + resolve(); + } + }) + }); } eos.finished = finished; @@ -770,274 +726,272 @@ eos.finished = finished; // Destroy function checkError(err, w, r) { - if (err) { - // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364 - err.stack; // eslint-disable-line no-unused-expressions + if (err) { + // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364 + err.stack; // eslint-disable-line no-unused-expressions - if (w && !w.errored) { - w.errored = err; - } - if (r && !r.errored) { - r.errored = err; - } + if (w && !w.errored) { + w.errored = err; } + if (r && !r.errored) { + r.errored = err; + } + } } export function destroy(err, cb) { - const r = this._readableState; - const w = this._writableState; - // With duplex streams we use the writable side for state. - const s = w || r; - if ((w && w.destroyed) || (r && r.destroyed)) { - if (typeof cb === "function") { - cb(); - } - return this; + const r = this._readableState; + const w = this._writableState; + // With duplex streams we use the writable side for state. + const s = w || r; + if ((w && w.destroyed) || (r && r.destroyed)) { + if (typeof cb === 'function') { + cb(); } + return this; + } + + // We set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks + checkError(err, w, r); + if (w) { + w.destroyed = true; + } + if (r) { + r.destroyed = true; + } + + // If still constructing then defer calling _destroy. + if (!s.constructed) { + this.once(kDestroy, function (er) { + _destroy(this, aggregateTwoErrors(er, err), cb); + }); + } else { + _destroy(this, err, cb); + } + return this; +} - // We set destroyed to true before firing error callbacks in order - // to make it re-entrance safe in case destroy() is called within callbacks +function _destroy(self, err, cb) { + let called = false; + function onDestroy(err) { + if (called) { + return; + } + called = true; + const r = self._readableState; + const w = self._writableState; checkError(err, w, r); if (w) { - w.destroyed = true; + w.closed = true; } if (r) { - r.destroyed = true; - } - - // If still constructing then defer calling _destroy. - if (!s.constructed) { - this.once(kDestroy, function (er) { - _destroy(this, aggregateTwoErrors(er, err), cb); - }); - } else { - _destroy(this, err, cb); + r.closed = true; } - return this; -} - -function _destroy(self, err, cb) { - let called = false; - function onDestroy(err) { - if (called) { - return; - } - called = true; - const r = self._readableState; - const w = self._writableState; - checkError(err, w, r); - if (w) { - w.closed = true; - } - if (r) { - r.closed = true; - } - if (typeof cb === "function") { - cb(err); - } - if (err) { - process.nextTick(emitErrorCloseNT, self, err); - } else { - process.nextTick(emitCloseNT, self); - } + if (typeof cb === 'function') { + cb(err); } - try { - self._destroy(err || null, onDestroy); - } catch (err) { - onDestroy(err); + if (err) { + process.nextTick(emitErrorCloseNT, self, err); + } else { + process.nextTick(emitCloseNT, self); } + } + try { + self._destroy(err || null, onDestroy); + } catch (err) { + onDestroy(err); + } } function emitErrorCloseNT(self, err) { - emitErrorNT(self, err); - emitCloseNT(self); + emitErrorNT(self, err); + emitCloseNT(self); } function emitCloseNT(self) { - const r = self._readableState; - const w = self._writableState; - if (w) { - w.closeEmitted = true; - } - if (r) { - r.closeEmitted = true; - } - if ((w && w.emitClose) || (r && r.emitClose)) { - self.emit("close"); - } + const r = self._readableState; + const w = self._writableState; + if (w) { + w.closeEmitted = true; + } + if (r) { + r.closeEmitted = true; + } + if ((w && w.emitClose) || (r && r.emitClose)) { + self.emit('close'); + } } function emitErrorNT(self, err) { - const r = self._readableState; - const w = self._writableState; - if ((w && w.errorEmitted) || (r && r.errorEmitted)) { - return; - } - if (w) { - w.errorEmitted = true; - } - if (r) { - r.errorEmitted = true; - } - self.emit("error", err); + const r = self._readableState; + const w = self._writableState; + if ((w && w.errorEmitted) || (r && r.errorEmitted)) { + return; + } + if (w) { + w.errorEmitted = true; + } + if (r) { + r.errorEmitted = true; + } + self.emit('error', err); } export function undestroy() { - const r = this._readableState; - const w = this._writableState; - if (r) { - r.constructed = true; - r.closed = false; - r.closeEmitted = false; - r.destroyed = false; - r.errored = null; - r.errorEmitted = false; - r.reading = false; - r.ended = r.readable === false; - r.endEmitted = r.readable === false; - } - if (w) { - w.constructed = true; - w.destroyed = false; - w.closed = false; - w.closeEmitted = false; - w.errored = null; - w.errorEmitted = false; - w.finalCalled = false; - w.prefinished = false; - w.ended = w.writable === false; - w.ending = w.writable === false; - w.finished = w.writable === false; - } + const r = this._readableState; + const w = this._writableState; + if (r) { + r.constructed = true; + r.closed = false; + r.closeEmitted = false; + r.destroyed = false; + r.errored = null; + r.errorEmitted = false; + r.reading = false; + r.ended = r.readable === false; + r.endEmitted = r.readable === false; + } + if (w) { + w.constructed = true; + w.destroyed = false; + w.closed = false; + w.closeEmitted = false; + w.errored = null; + w.errorEmitted = false; + w.finalCalled = false; + w.prefinished = false; + w.ended = w.writable === false; + w.ending = w.writable === false; + w.finished = w.writable === false; + } } export function errorOrDestroy(stream, err, sync = false) { - // We have tests that rely on errors being emitted - // in the same tick, so changing this is semver major. - // For now when you opt-in to autoDestroy we allow - // the error to be emitted nextTick. In a future - // semver major update we should change the default to this. - - const r = stream._readableState; - const w = stream._writableState; - if ((w && w.destroyed) || (r && r.destroyed)) { - return; - } - if ((r && r.autoDestroy) || (w && w.autoDestroy)) stream.destroy(err); - else if (err) { - // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364 - err.stack; // eslint-disable-line no-unused-expressions - - if (w && !w.errored) { - w.errored = err; - } - if (r && !r.errored) { - r.errored = err; - } - if (sync) { - process.nextTick(emitErrorNT, stream, err); - } else { - emitErrorNT(stream, err); - } + // We have tests that rely on errors being emitted + // in the same tick, so changing this is semver major. + // For now when you opt-in to autoDestroy we allow + // the error to be emitted nextTick. In a future + // semver major update we should change the default to this. + + const r = stream._readableState; + const w = stream._writableState; + if ((w && w.destroyed) || (r && r.destroyed)) { + return; + } + if ((r && r.autoDestroy) || (w && w.autoDestroy)) stream.destroy(err); + else if (err) { + // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364 + err.stack; // eslint-disable-line no-unused-expressions + + if (w && !w.errored) { + w.errored = err; + } + if (r && !r.errored) { + r.errored = err; + } + if (sync) { + process.nextTick(emitErrorNT, stream, err); + } else { + emitErrorNT(stream, err) } + } } export function construct(stream, cb) { - if (typeof stream._construct !== "function") { - return; + if (typeof stream._construct !== 'function') { + return; + } + const r = stream._readableState; + const w = stream._writableState; + if (r) { + r.constructed = false; + } + if (w) { + w.constructed = false; + } + stream.once(kConstruct, cb) + if (stream.listenerCount(kConstruct) > 1) { + // Duplex + return; + } + process.nextTick(constructNT, stream); +} + +function constructNT(stream) { + let called = false; + function onConstruct(err) { + if (called) { + errorOrDestroy(stream, err !== null && err !== undefined ? err : new ERR_MULTIPLE_CALLBACK()); + return; } + called = true; const r = stream._readableState; const w = stream._writableState; + const s = w || r; if (r) { - r.constructed = false; + r.constructed = true; } if (w) { - w.constructed = false; + w.constructed = true; } - stream.once(kConstruct, cb); - if (stream.listenerCount(kConstruct) > 1) { - // Duplex - return; - } - process.nextTick(constructNT, stream); -} - -function constructNT(stream) { - let called = false; - function onConstruct(err) { - if (called) { - errorOrDestroy( - stream, - err !== null && err !== undefined ? err : new ERR_MULTIPLE_CALLBACK() - ); - return; - } - called = true; - const r = stream._readableState; - const w = stream._writableState; - const s = w || r; - if (r) { - r.constructed = true; - } - if (w) { - w.constructed = true; - } - if (s.destroyed) { - stream.emit(kDestroy, err); - } else if (err) { - errorOrDestroy(stream, err, true); - } else { - process.nextTick(emitConstructNT, stream); - } - } - try { - stream._construct(onConstruct); - } catch (err) { - onConstruct(err); + if (s.destroyed) { + stream.emit(kDestroy, err); + } else if (err) { + errorOrDestroy(stream, err, true); + } else { + process.nextTick(emitConstructNT, stream); } + } + try { + stream._construct(onConstruct); + } catch (err) { + onConstruct(err); + } } function emitConstructNT(stream) { - stream.emit(kConstruct); + stream.emit(kConstruct); } function emitCloseLegacy(stream) { - stream.emit("close"); + stream.emit('close'); } function emitErrorCloseLegacy(stream, err) { - stream.emit("error", err); - process.nextTick(emitCloseLegacy, stream); + stream.emit('error', err); + process.nextTick(emitCloseLegacy, stream); } // Normalize destroy for legacy. export function destroyer(stream, err) { - if (!stream || isDestroyed(stream)) { - return; - } - if (!err && !isFinished(stream)) { - err = new AbortError(); - } - - // TODO: Remove isRequest branches. - if (isServerRequest(stream)) { - stream.socket = null; - stream.destroy(err); - } else if (isRequest(stream)) { - stream.abort(); - } else if (isRequest(stream.req)) { - stream.req.abort(); - } else if (typeof stream.destroy === "function") { - stream.destroy(err); - } else if (typeof stream.close === "function") { - // TODO: Don't lose err? - stream.close(); - } else if (err) { - process.nextTick(emitErrorCloseLegacy, stream, err); - } else { - process.nextTick(emitCloseLegacy, stream); - } - if (!stream.destroyed) { - stream[kDestroyed] = true; - } + if (!stream || isDestroyed(stream)) { + return; + } + if (!err && !isFinished(stream)) { + err = new AbortError(); + } + + // TODO: Remove isRequest branches. + if (isServerRequest(stream)) { + stream.socket = null; + stream.destroy(err); + } else if (isRequest(stream)) { + stream.abort(); + } else if (isRequest(stream.req)) { + stream.req.abort(); + } else if (typeof stream.destroy === 'function') { + stream.destroy(err); + } else if (typeof stream.close === 'function') { + // TODO: Don't lose err? + stream.close(); + } else if (err) { + process.nextTick(emitErrorCloseLegacy, stream, err); + } else { + process.nextTick(emitCloseLegacy, stream); + } + if (!stream.destroyed) { + stream[kDestroyed] = true; + } } + diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_writable.js b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_writable.js index 6a288b6d6..f356c6794 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_writable.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/streams_writable.js @@ -1,179 +1,185 @@ -import EventEmitter from "./events"; +import + EventEmitter + from './events'; -import { Stream } from "./streams_legacy"; +import { + Stream +} from './streams_legacy'; -import { Buffer } from "./internal_buffer"; +import { + Buffer, +} from './internal_buffer'; -import * as process from "./process"; +import * as process from './process'; import { - nop, - kOnFinished, - getHighWaterMark, - getDefaultHighWaterMark, - addAbortSignal, - construct, - destroy, - undestroy, - errorOrDestroy, -} from "./streams_util"; + nop, + kOnFinished, + getHighWaterMark, + getDefaultHighWaterMark, + addAbortSignal, + construct, + destroy, + undestroy, + errorOrDestroy, +} from './streams_util'; import { - newStreamWritableFromWritableStream, - newWritableStreamFromStreamWritable, -} from "./streams_adapters"; + newStreamWritableFromWritableStream, + newWritableStreamFromStreamWritable, +} from './streams_adapters'; import { - ERR_INVALID_ARG_TYPE, - ERR_METHOD_NOT_IMPLEMENTED, - ERR_MULTIPLE_CALLBACK, - ERR_STREAM_CANNOT_PIPE, - ERR_STREAM_DESTROYED, - ERR_STREAM_ALREADY_FINISHED, - ERR_STREAM_NULL_VALUES, - ERR_STREAM_WRITE_AFTER_END, - ERR_UNKNOWN_ENCODING, -} from "./internal_errors"; - -import { isDuplexInstance } from "./streams_duplex"; + ERR_INVALID_ARG_TYPE, + ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK, + ERR_STREAM_CANNOT_PIPE, + ERR_STREAM_DESTROYED, + ERR_STREAM_ALREADY_FINISHED, + ERR_STREAM_NULL_VALUES, + ERR_STREAM_WRITE_AFTER_END, + ERR_UNKNOWN_ENCODING +} from './internal_errors'; + +import { isDuplexInstance } from './streams_duplex'; // ====================================================================================== // WritableState function WritableState(options, stream, isDuplex) { - // Duplex streams are both readable and writable, but share - // the same options object. - // However, some cases require setting options to different - // values for the readable and the writable sides of the duplex stream, - // e.g. options.readableObjectMode vs. options.writableObjectMode, etc. - if (typeof isDuplex !== "boolean") isDuplex = isDuplexInstance(stream); - - // Object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options?.objectMode; - if (isDuplex) this.objectMode = this.objectMode || !!options?.writableObjectMode; - - // The point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write(). - this.highWaterMark = options - ? getHighWaterMark(this, options, "writableHighWaterMark", isDuplex) - : getDefaultHighWaterMark(false); - - // if _final has been called. - this.finalCalled = false; - - // drain event flag. - this.needDrain = false; - // At the start of calling end() - this.ending = false; - // When end() has been called, and returned. - this.ended = false; - // When 'finish' is emitted. - this.finished = false; - - // Has it been destroyed - this.destroyed = false; - - // Should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - const noDecode = !!(options?.decodeStrings === false); - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options?.defaultEncoding || "utf8"; - - // Not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // A flag to see when we're in the middle of a write. - this.writing = false; - - // When true all writes will be buffered until .uncork() call. - this.corked = 0; - - // A flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // A flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // The callback that's passed to _write(chunk, cb). - this.onwrite = (err) => onwrite.call(undefined, stream, err); - - // The callback that the user supplies to write(chunk, encoding, cb). - this.writecb = null; - - // The amount that is being written when _write is called. - this.writelen = 0; - - // Storage for data passed to the afterWrite() callback in case of - // synchronous _write() completion. - this.afterWriteTickInfo = null; - resetBuffer(this); - - // Number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted. - this.pendingcb = 0; - - // Stream is still being constructed and cannot be - // destroyed until construction finished or failed. - // Async construction is opt in, therefore we start as - // constructed. - this.constructed = true; - - // Emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams. - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again. - this.errorEmitted = false; - - // Should close be emitted on destroy. Defaults to true. - this.emitClose = !options || options.emitClose !== false; - - // Should .destroy() be called after 'finish' (and potentially 'end'). - this.autoDestroy = !options || options.autoDestroy !== false; - - // Indicates whether the stream has errored. When true all write() calls - // should return false. This is needed since when autoDestroy - // is disabled we need a way to tell whether the stream has failed. - this.errored = null; - - // Indicates whether the stream has finished destroying. - this.closed = false; - - // True if close has been emitted or would have been emitted - // depending on emitClose. - this.closeEmitted = false; - this[kOnFinished] = []; + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream, + // e.g. options.readableObjectMode vs. options.writableObjectMode, etc. + if (typeof isDuplex !== 'boolean') isDuplex = isDuplexInstance(stream); + + // Object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!(options?.objectMode); + if (isDuplex) this.objectMode = this.objectMode || !!(options?.writableObjectMode); + + // The point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write(). + this.highWaterMark = options + ? getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex) + : getDefaultHighWaterMark(false); + + // if _final has been called. + this.finalCalled = false; + + // drain event flag. + this.needDrain = false; + // At the start of calling end() + this.ending = false; + // When end() has been called, and returned. + this.ended = false; + // When 'finish' is emitted. + this.finished = false; + + // Has it been destroyed + this.destroyed = false; + + // Should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + const noDecode = !!(options?.decodeStrings === false); + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = (options?.defaultEncoding) || 'utf8'; + + // Not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // A flag to see when we're in the middle of a write. + this.writing = false; + + // When true all writes will be buffered until .uncork() call. + this.corked = 0; + + // A flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // A flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // The callback that's passed to _write(chunk, cb). + this.onwrite = (err) => onwrite.call(undefined, stream, err); + + // The callback that the user supplies to write(chunk, encoding, cb). + this.writecb = null; + + // The amount that is being written when _write is called. + this.writelen = 0; + + // Storage for data passed to the afterWrite() callback in case of + // synchronous _write() completion. + this.afterWriteTickInfo = null; + resetBuffer(this); + + // Number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted. + this.pendingcb = 0; + + // Stream is still being constructed and cannot be + // destroyed until construction finished or failed. + // Async construction is opt in, therefore we start as + // constructed. + this.constructed = true; + + // Emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams. + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again. + this.errorEmitted = false; + + // Should close be emitted on destroy. Defaults to true. + this.emitClose = !options || options.emitClose !== false; + + // Should .destroy() be called after 'finish' (and potentially 'end'). + this.autoDestroy = !options || options.autoDestroy !== false; + + // Indicates whether the stream has errored. When true all write() calls + // should return false. This is needed since when autoDestroy + // is disabled we need a way to tell whether the stream has failed. + this.errored = null; + + // Indicates whether the stream has finished destroying. + this.closed = false; + + // True if close has been emitted or would have been emitted + // depending on emitClose. + this.closeEmitted = false; + this[kOnFinished] = []; } function resetBuffer(state) { - state.buffered = []; - state.bufferedIndex = 0; - state.allBuffers = true; - state.allNoop = true; + state.buffered = []; + state.bufferedIndex = 0; + state.allBuffers = true; + state.allNoop = true; } WritableState.prototype.getBuffer = function getBuffer() { - return this.buffered.slice(this.bufferedIndex); -}; + return this.buffered.slice(this.bufferedIndex); +} -Object.defineProperty(WritableState.prototype, "bufferedRequestCount", { - get() { - return this.buffered.length - this.bufferedIndex; - }, +Object.defineProperty(WritableState.prototype, 'bufferedRequestCount', { + get() { + return this.buffered.length - this.bufferedIndex; + } }); // ====================================================================================== @@ -185,117 +191,117 @@ Object.setPrototypeOf(Writable.prototype, Stream.prototype); Object.setPrototypeOf(Writable, Stream); export function Writable(options) { - // Writable ctor is applied to Duplexes, too. - // `realHasInstance` is necessary because using plain `instanceof` - // would return false, as no `_writableState` property is attached. - - // Trying to use the custom `instanceof` for Writable here will also break the - // Node.js LazyTransform implementation, which has a non-trivial getter for - // `_writableState` that would lead to infinite recursion. - - // Checking for a Stream.Duplex instance is faster here instead of inside - // the WritableState constructor, at least with V8 6.5. - const isDuplex = isDuplexInstance(this); - if (!isDuplex && !Writable[Symbol.hasInstance](this)) return new Writable(options); - this._writableState = new WritableState(options, this, isDuplex); - if (options) { - if (typeof options.write === "function") this._write = options.write; - if (typeof options.writev === "function") this._writev = options.writev; - if (typeof options.destroy === "function") this._destroy = options.destroy; - if (typeof options.final === "function") this._final = options.final; - if (typeof options.construct === "function") this._construct = options.construct; - if (options.signal) addAbortSignal(options.signal, this); + // Writable ctor is applied to Duplexes, too. + // `realHasInstance` is necessary because using plain `instanceof` + // would return false, as no `_writableState` property is attached. + + // Trying to use the custom `instanceof` for Writable here will also break the + // Node.js LazyTransform implementation, which has a non-trivial getter for + // `_writableState` that would lead to infinite recursion. + + // Checking for a Stream.Duplex instance is faster here instead of inside + // the WritableState constructor, at least with V8 6.5. + const isDuplex = isDuplexInstance(this); + if (!isDuplex && !Writable[Symbol.hasInstance](this)) return new Writable(options); + this._writableState = new WritableState(options, this, isDuplex) + if (options) { + if (typeof options.write === 'function') this._write = options.write; + if (typeof options.writev === 'function') this._writev = options.writev; + if (typeof options.destroy === 'function') this._destroy = options.destroy; + if (typeof options.final === 'function') this._final = options.final; + if (typeof options.construct === 'function') this._construct = options.construct; + if (options.signal) addAbortSignal(options.signal, this); + } + Stream.call(this, options); + construct(this, () => { + const state = this._writableState; + if (!state.writing) { + clearBuffer(this, state); } - Stream.call(this, options); - construct(this, () => { - const state = this._writableState; - if (!state.writing) { - clearBuffer(this, state); - } - finishMaybe(this, state); - }); + finishMaybe(this, state); + }) } Object.defineProperty(Writable, Symbol.hasInstance, { - value: function (object) { - if (Function.prototype[Symbol.hasInstance].call(this, object)) return true; - if (this !== Writable) return false; - return object?._writableState instanceof WritableState; - }, -}); + value: function (object) { + if (Function.prototype[Symbol.hasInstance].call(this, object)) return true; + if (this !== Writable) return false; + return object?._writableState instanceof WritableState; + } +}) // Otherwise people can pipe Writable streams, which is just wrong. Writable.prototype.pipe = function (_1, _2) { - errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE()); -}; + errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE()); +} function _write(stream, chunk, encoding, cb) { - const state = stream._writableState; - if (typeof encoding === "function") { - cb = encoding; - encoding = state.defaultEncoding; - } else { - if (!encoding) encoding = state.defaultEncoding; - else if (encoding !== "buffer" && !Buffer.isEncoding(encoding)) { - throw new ERR_UNKNOWN_ENCODING(encoding); - } - if (typeof cb !== "function") cb = nop; + const state = stream._writableState; + if (typeof encoding === 'function') { + cb = encoding; + encoding = state.defaultEncoding; + } else { + if (!encoding) encoding = state.defaultEncoding; + else if (encoding !== 'buffer' && !Buffer.isEncoding(encoding)) { + throw new ERR_UNKNOWN_ENCODING(encoding); } - if (chunk === null) { - throw new ERR_STREAM_NULL_VALUES(); - } else if (!state.objectMode) { - if (typeof chunk === "string") { - if (state.decodeStrings !== false) { - chunk = Buffer.from(chunk, encoding); - encoding = "buffer"; - } - } else if (chunk instanceof Buffer) { - encoding = "buffer"; - } else if (Stream._isUint8Array(chunk)) { - chunk = Stream._uint8ArrayToBuffer(chunk); - encoding = "buffer"; - } else { - throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk); - } - } - let err; - if (state.ending) { - err = new ERR_STREAM_WRITE_AFTER_END(); - } else if (state.destroyed) { - err = new ERR_STREAM_DESTROYED("write"); - } - if (err) { - process.nextTick(cb, err); - errorOrDestroy(stream, err, true); - return err; + if (typeof cb !== 'function') cb = nop; + } + if (chunk === null) { + throw new ERR_STREAM_NULL_VALUES(); + } else if (!state.objectMode) { + if (typeof chunk === 'string') { + if (state.decodeStrings !== false) { + chunk = Buffer.from(chunk, encoding); + encoding = 'buffer'; + } + } else if (chunk instanceof Buffer) { + encoding = 'buffer'; + } else if (Stream._isUint8Array(chunk)) { + chunk = Stream._uint8ArrayToBuffer(chunk); + encoding = 'buffer'; + } else { + throw new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk); } - state.pendingcb++; - return writeOrBuffer(stream, state, chunk, encoding, cb); + } + let err; + if (state.ending) { + err = new ERR_STREAM_WRITE_AFTER_END(); + } else if (state.destroyed) { + err = new ERR_STREAM_DESTROYED('write'); + } + if (err) { + process.nextTick(cb, err); + errorOrDestroy(stream, err, true); + return err; + } + state.pendingcb++; + return writeOrBuffer(stream, state, chunk, encoding, cb); } function write(chunk, encoding, cb) { - return _write(this, chunk, encoding, cb) === true; + return _write(this, chunk, encoding, cb) === true; } Writable.prototype.write = write; Writable.prototype.cork = function () { - this._writableState.corked++; -}; + this._writableState.corked++; +} Writable.prototype.uncork = function () { - const state = this._writableState; - if (state.corked) { - state.corked--; - if (!state.writing) clearBuffer(this, state); - } -}; + const state = this._writableState; + if (state.corked) { + state.corked--; + if (!state.writing) clearBuffer(this, state); + } +} function setDefaultEncoding(encoding) { - if (typeof encoding === "string") encoding = encoding.toLowerCase(); - if (!Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding); - this._writableState.defaultEncoding = encoding; - return this; + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding); + this._writableState.defaultEncoding = encoding; + return this; } Writable.prototype.setDefaultEncoding = setDefaultEncoding; @@ -304,513 +310,506 @@ Writable.prototype.setDefaultEncoding = setDefaultEncoding; // in the queue, and wait our turn. Otherwise, call _write // If we return false, then we need a drain event, so set that flag. function writeOrBuffer(stream, state, chunk, encoding, callback) { - const len = state.objectMode ? 1 : chunk.length; - state.length += len; - - // stream._write resets state.length - const ret = state.length < state.highWaterMark; - // We must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - if (state.writing || state.corked || state.errored || !state.constructed) { - state.buffered.push({ - chunk, - encoding, - callback, - }); - if (state.allBuffers && encoding !== "buffer") { - state.allBuffers = false; - } - if (state.allNoop && callback !== nop) { - state.allNoop = false; - } - } else { - state.writelen = len; - state.writecb = callback; - state.writing = true; - state.sync = true; - stream._write(chunk, encoding, state.onwrite); - state.sync = false; + const len = state.objectMode ? 1 : chunk.length; + state.length += len; + + // stream._write resets state.length + const ret = state.length < state.highWaterMark; + // We must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + if (state.writing || state.corked || state.errored || !state.constructed) { + state.buffered.push({ + chunk, + encoding, + callback, + }); + if (state.allBuffers && encoding !== 'buffer') { + state.allBuffers = false; } - - // Return false if errored or destroyed in order to break - // any synchronous while(stream.write(data)) loops. - return ret && !state.errored && !state.destroyed; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { + if (state.allNoop && callback !== nop) { + state.allNoop = false; + } + } else { state.writelen = len; - state.writecb = cb; + state.writecb = callback; state.writing = true; state.sync = true; - if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED("write")); - else if (writev) stream._writev(chunk, state.onwrite); - else stream._write(chunk, encoding, state.onwrite); + stream._write(chunk, encoding, state.onwrite); state.sync = false; + } + + // Return false if errored or destroyed in order to break + // any synchronous while(stream.write(data)) loops. + return ret && !state.errored && !state.destroyed; +} + +function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write')); + else if (writev) stream._writev(chunk, state.onwrite); + else stream._write(chunk, encoding, state.onwrite); + state.sync = false; } function onwriteError(stream, state, er, cb) { - --state.pendingcb; - cb(er); - // Ensure callbacks are invoked even when autoDestroy is - // not enabled. Passing `er` here doesn't make sense since - // it's related to one specific write, not to the buffered - // writes. - errorBuffer(state); - // This can emit error, but error must always follow cb. - errorOrDestroy(stream, er); + --state.pendingcb; + cb(er); + // Ensure callbacks are invoked even when autoDestroy is + // not enabled. Passing `er` here doesn't make sense since + // it's related to one specific write, not to the buffered + // writes. + errorBuffer(state); + // This can emit error, but error must always follow cb. + errorOrDestroy(stream, er); } function onwrite(stream, er) { - const state = stream._writableState; - const sync = state.sync; - const cb = state.writecb; - if (typeof cb !== "function") { - errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK()); - return; + const state = stream._writableState; + const sync = state.sync; + const cb = state.writecb; + if (typeof cb !== 'function') { + errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK()); + return; + } + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; + if (er) { + // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364 + er.stack; // eslint-disable-line no-unused-expressions + + if (!state.errored) { + state.errored = er; } - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; - if (er) { - // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364 - er.stack; // eslint-disable-line no-unused-expressions - - if (!state.errored) { - state.errored = er; - } - // In case of duplex streams we need to notify the readable side of the - // error. - if (stream._readableState && !stream._readableState.errored) { - stream._readableState.errored = er; - } - if (sync) { - process.nextTick(onwriteError, stream, state, er, cb); - } else { - onwriteError(stream, state, er, cb); - } + // In case of duplex streams we need to notify the readable side of the + // error. + if (stream._readableState && !stream._readableState.errored) { + stream._readableState.errored = er; + } + if (sync) { + process.nextTick(onwriteError, stream, state, er, cb); } else { - if (state.buffered.length > state.bufferedIndex) { - clearBuffer(stream, state); - } - if (sync) { - // It is a common case that the callback passed to .write() is always - // the same. In that case, we do not schedule a new nextTick(), but - // rather just increase a counter, to improve performance and avoid - // memory allocations. - if (state.afterWriteTickInfo !== null && state.afterWriteTickInfo.cb === cb) { - state.afterWriteTickInfo.count++; - } else { - state.afterWriteTickInfo = { - count: 1, - cb, - stream, - state, - }; - process.nextTick(afterWriteTick, state.afterWriteTickInfo); - } - } else { - afterWrite(stream, state, 1, cb); - } + onwriteError(stream, state, er, cb); + } + } else { + if (state.buffered.length > state.bufferedIndex) { + clearBuffer(stream, state); + } + if (sync) { + // It is a common case that the callback passed to .write() is always + // the same. In that case, we do not schedule a new nextTick(), but + // rather just increase a counter, to improve performance and avoid + // memory allocations. + if (state.afterWriteTickInfo !== null && state.afterWriteTickInfo.cb === cb) { + state.afterWriteTickInfo.count++; + } else { + state.afterWriteTickInfo = { + count: 1, + cb, + stream, + state + }; + process.nextTick(afterWriteTick, state.afterWriteTickInfo); + } + } else { + afterWrite(stream, state, 1, cb); } + } } function afterWriteTick({ stream, state, count, cb }) { - state.afterWriteTickInfo = null; - return afterWrite(stream, state, count, cb); + state.afterWriteTickInfo = null; + return afterWrite(stream, state, count, cb); } function afterWrite(stream, state, count, cb) { - const needDrain = !state.ending && !stream.destroyed && state.length === 0 && state.needDrain; - if (needDrain) { - state.needDrain = false; - stream.emit("drain"); - } - while (count-- > 0) { - state.pendingcb--; - cb(); - } - if (state.destroyed) { - errorBuffer(state); - } - finishMaybe(stream, state); + const needDrain = !state.ending && !stream.destroyed && state.length === 0 && state.needDrain; + if (needDrain) { + state.needDrain = false; + stream.emit('drain'); + } + while (count-- > 0) { + state.pendingcb--; + cb(); + } + if (state.destroyed) { + errorBuffer(state); + } + finishMaybe(stream, state); } // If there's something in the buffer waiting, then invoke callbacks. function errorBuffer(state) { - if (state.writing) { - return; - } - for (let n = state.bufferedIndex; n < state.buffered.length; ++n) { - let _state$errored; - const { chunk, callback } = state.buffered[n]; - const len = state.objectMode ? 1 : chunk.length; - state.length -= len; - callback( - (_state$errored = state.errored) !== null && _state$errored !== undefined - ? _state$errored - : new ERR_STREAM_DESTROYED("write") - ); - } - const onfinishCallbacks = state[kOnFinished].splice(0); - for (let i = 0; i < onfinishCallbacks.length; i++) { - let _state$errored2; - onfinishCallbacks[i]( - (_state$errored2 = state.errored) !== null && _state$errored2 !== undefined - ? _state$errored2 - : new ERR_STREAM_DESTROYED("end") - ); - } - resetBuffer(state); + if (state.writing) { + return; + } + for (let n = state.bufferedIndex; n < state.buffered.length; ++n) { + let _state$errored; + const { chunk, callback } = state.buffered[n]; + const len = state.objectMode ? 1 : chunk.length; + state.length -= len; + callback( + (_state$errored = state.errored) !== null && _state$errored !== undefined + ? _state$errored + : new ERR_STREAM_DESTROYED('write')); + } + const onfinishCallbacks = state[kOnFinished].splice(0); + for (let i = 0; i < onfinishCallbacks.length; i++) { + let _state$errored2; + onfinishCallbacks[i]( + (_state$errored2 = state.errored) !== null && _state$errored2 !== undefined + ? _state$errored2 + : new ERR_STREAM_DESTROYED('end')); + } + resetBuffer(state); } // If there's something in the buffer waiting, then process it. function clearBuffer(stream, state) { - if (state.corked || state.bufferProcessing || state.destroyed || !state.constructed) { - return; - } - const { buffered, bufferedIndex, objectMode } = state; - const bufferedLength = buffered.length - bufferedIndex; - if (!bufferedLength) { - return; - } - let i = bufferedIndex; - state.bufferProcessing = true; - if (bufferedLength > 1 && stream._writev) { - state.pendingcb -= bufferedLength - 1; - const callback = state.allNoop - ? nop - : (err) => { - for (let n = i; n < buffered.length; ++n) { - buffered[n].callback(err); - } - }; - // Make a copy of `buffered` if it's going to be used by `callback` above, - // since `doWrite` will mutate the array. - const chunks = state.allNoop && i === 0 ? buffered : buffered.slice(i); - chunks.allBuffers = state.allBuffers; - doWrite(stream, state, true, state.length, chunks, "", callback); - resetBuffer(state); + if (state.corked || state.bufferProcessing || state.destroyed || !state.constructed) { + return; + } + const { buffered, bufferedIndex, objectMode } = state; + const bufferedLength = buffered.length - bufferedIndex; + if (!bufferedLength) { + return; + } + let i = bufferedIndex; + state.bufferProcessing = true; + if (bufferedLength > 1 && stream._writev) { + state.pendingcb -= bufferedLength - 1; + const callback = state.allNoop + ? nop + : (err) => { + for (let n = i; n < buffered.length; ++n) { + buffered[n].callback(err) + } + }; + // Make a copy of `buffered` if it's going to be used by `callback` above, + // since `doWrite` will mutate the array. + const chunks = state.allNoop && i === 0 ? buffered : buffered.slice(i); + chunks.allBuffers = state.allBuffers; + doWrite(stream, state, true, state.length, chunks, '', callback); + resetBuffer(state); + } else { + do { + const { chunk, encoding, callback } = buffered[i]; + buffered[i++] = null; + const len = objectMode ? 1 : chunk.length; + doWrite(stream, state, false, len, chunk, encoding, callback); + } while (i < buffered.length && !state.writing) + if (i === buffered.length) { + resetBuffer(state); + } else if (i > 256) { + buffered.splice(0, i); + state.bufferedIndex = 0; } else { - do { - const { chunk, encoding, callback } = buffered[i]; - buffered[i++] = null; - const len = objectMode ? 1 : chunk.length; - doWrite(stream, state, false, len, chunk, encoding, callback); - } while (i < buffered.length && !state.writing); - if (i === buffered.length) { - resetBuffer(state); - } else if (i > 256) { - buffered.splice(0, i); - state.bufferedIndex = 0; - } else { - state.bufferedIndex = i; - } + state.bufferedIndex = i; } - state.bufferProcessing = false; + } + state.bufferProcessing = false; } Writable.prototype._write = function (chunk, encoding, cb) { - if (this._writev) { - this._writev( - [ - { - chunk, - encoding, - }, - ], - cb - ); - } else { - throw new ERR_METHOD_NOT_IMPLEMENTED("_write()"); - } -}; + if (this._writev) { + this._writev( + [ + { + chunk, + encoding + } + ], + cb, + ); + } else { + throw new ERR_METHOD_NOT_IMPLEMENTED('_write()'); + } +} Writable.prototype._writev = null; function end(chunk, encoding, cb) { - const state = this._writableState; - if (typeof chunk === "function") { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === "function") { - cb = encoding; - encoding = null; + const state = this._writableState; + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + let err; + if (chunk !== null && chunk !== undefined) { + const ret = _write(this, chunk, encoding); + if (ret instanceof Error) { + err = ret; } - let err; - if (chunk !== null && chunk !== undefined) { - const ret = _write(this, chunk, encoding); - if (ret instanceof Error) { - err = ret; - } - } - - // .end() fully uncorks. - if (state.corked) { - state.corked = 1; - this.uncork(); - } - if (err) { - // Do nothing... - } else if (!state.errored && !state.ending) { - // This is forgiving in terms of unnecessary calls to end() and can hide - // logic errors. However, usually such errors are harmless and causing a - // hard error can be disproportionately destructive. It is not always - // trivial for the user to determine whether end() needs to be called - // or not. - - state.ending = true; - finishMaybe(this, state, true); - state.ended = true; - } else if (state.finished) { - err = new ERR_STREAM_ALREADY_FINISHED("end"); - } else if (state.destroyed) { - err = new ERR_STREAM_DESTROYED("end"); - } - if (typeof cb === "function") { - if (err || state.finished) { - process.nextTick(cb, err); - } else { - state[kOnFinished].push(cb); - } + } + + // .end() fully uncorks. + if (state.corked) { + state.corked = 1; + this.uncork(); + } + if (err) { + // Do nothing... + } else if (!state.errored && !state.ending) { + // This is forgiving in terms of unnecessary calls to end() and can hide + // logic errors. However, usually such errors are harmless and causing a + // hard error can be disproportionately destructive. It is not always + // trivial for the user to determine whether end() needs to be called + // or not. + + state.ending = true; + finishMaybe(this, state, true); + state.ended = true; + } else if (state.finished) { + err = new ERR_STREAM_ALREADY_FINISHED('end'); + } else if (state.destroyed) { + err = new ERR_STREAM_DESTROYED('end'); + } + if (typeof cb === 'function') { + if (err || state.finished) { + process.nextTick(cb, err); + } else { + state[kOnFinished].push(cb); } - return this; + } + return this; } Writable.prototype.end = end; function needFinish(state) { - return ( - state.ending && - !state.destroyed && - state.constructed && - state.length === 0 && - !state.errored && - state.buffered.length === 0 && - !state.finished && - !state.writing && - !state.errorEmitted && - !state.closeEmitted - ); + return ( + state.ending && + !state.destroyed && + state.constructed && + state.length === 0 && + !state.errored && + state.buffered.length === 0 && + !state.finished && + !state.writing && + !state.errorEmitted && + !state.closeEmitted + ); } function callFinal(stream, state) { - let called = false; - function onFinish(err) { - if (called) { - errorOrDestroy(stream, err || new ERR_MULTIPLE_CALLBACK()); - return; - } - called = true; - state.pendingcb--; - if (err) { - const onfinishCallbacks = state[kOnFinished].splice(0); - for (let i = 0; i < onfinishCallbacks.length; i++) { - onfinishCallbacks[i](err); - } - errorOrDestroy(stream, err, state.sync); - } else if (needFinish(state)) { - state.prefinished = true; - stream.emit("prefinish"); - // Backwards compat. Don't check state.sync here. - // Some streams assume 'finish' will be emitted - // asynchronously relative to _final callback. - state.pendingcb++; - process.nextTick(finish, stream, state); - } + let called = false; + function onFinish(err) { + if (called) { + errorOrDestroy(stream, err || new ERR_MULTIPLE_CALLBACK()); + return; } - state.sync = true; - state.pendingcb++; - try { - stream._final(onFinish); - } catch (err) { - onFinish(err); + called = true; + state.pendingcb--; + if (err) { + const onfinishCallbacks = state[kOnFinished].splice(0); + for (let i = 0; i < onfinishCallbacks.length; i++) { + onfinishCallbacks[i](err); + } + errorOrDestroy(stream, err, state.sync); + } else if (needFinish(state)) { + state.prefinished = true; + stream.emit('prefinish'); + // Backwards compat. Don't check state.sync here. + // Some streams assume 'finish' will be emitted + // asynchronously relative to _final callback. + state.pendingcb++; + process.nextTick(finish, stream, state); } - state.sync = false; + } + state.sync = true; + state.pendingcb++; + try { + stream._final(onFinish); + } catch (err) { + onFinish(err); + } + state.sync = false; } function prefinish(stream, state) { - if (!state.prefinished && !state.finalCalled) { - if (typeof stream._final === "function" && !state.destroyed) { - state.finalCalled = true; - callFinal(stream, state); - } else { - state.prefinished = true; - stream.emit("prefinish"); - } + if (!state.prefinished && !state.finalCalled) { + if (typeof stream._final === 'function' && !state.destroyed) { + state.finalCalled = true; + callFinal(stream, state); + } else { + state.prefinished = true; + stream.emit('prefinish'); } + } } function finishMaybe(stream, state, sync = false) { - if (needFinish(state)) { - prefinish(stream, state); - if (state.pendingcb === 0) { - if (sync) { - state.pendingcb++; - process.nextTick(() => { - ((stream, state) => { - if (needFinish(state)) { - finish(stream, state); - } else { - state.pendingcb--; - } - })(stream, state); - }); - } else if (needFinish(state)) { - state.pendingcb++; - finish(stream, state); + if (needFinish(state)) { + prefinish(stream, state); + if (state.pendingcb === 0) { + if (sync) { + state.pendingcb++; + process.nextTick(() => { + ((stream, state) => { + if (needFinish(state)) { + finish(stream, state); + } else { + state.pendingcb--; } - } + })(stream, state); + }); + } else if (needFinish(state)) { + state.pendingcb++; + finish(stream, state); + } } + } } function finish(stream, state) { - state.pendingcb--; - state.finished = true; - const onfinishCallbacks = state[kOnFinished].splice(0); - for (let i = 0; i < onfinishCallbacks.length; i++) { - onfinishCallbacks[i](); - } - stream.emit("finish"); - if (state.autoDestroy) { - // In case of duplex streams we need a way to detect - // if the readable side is ready for autoDestroy as well. - const rState = stream._readableState; - const autoDestroy = - !rState || - (rState.autoDestroy && - // We don't expect the readable to ever 'end' - // if readable is explicitly set to false. - (rState.endEmitted || rState.readable === false)); - if (autoDestroy) { - stream.destroy(); - } + state.pendingcb--; + state.finished = true; + const onfinishCallbacks = state[kOnFinished].splice(0); + for (let i = 0; i < onfinishCallbacks.length; i++) { + onfinishCallbacks[i](); + } + stream.emit('finish'); + if (state.autoDestroy) { + // In case of duplex streams we need a way to detect + // if the readable side is ready for autoDestroy as well. + const rState = stream._readableState; + const autoDestroy = + !rState || + (rState.autoDestroy && + // We don't expect the readable to ever 'end' + // if readable is explicitly set to false. + (rState.endEmitted || rState.readable === false)); + if (autoDestroy) { + stream.destroy(); } + } } Object.defineProperties(Writable.prototype, { - closed: { - get() { - return !!this._writableState?.closed; - }, - }, - destroyed: { - get() { - return !!this._writableState?.destroyed; - }, - set(value) { - // Backward compatibility, the user is explicitly managing destroyed. - if (this._writableState) { - this._writableState.destroyed = value; - } - }, - }, - errored: { - enumerable: false, - get() { - return this._writableState?.errored || null; - }, - }, - writable: { - get() { - const w = this._writableState; - // w.writable === false means that this is part of a Duplex stream - // where the writable side was disabled upon construction. - // Compat. The user might manually disable writable side through - // deprecated setter. - return ( - !!w && w.writable !== false && !w.destroyed && !w.errored && !w.ending && !w.ended - ); - }, - set(val) { - // Backwards compatible. - if (this._writableState) { - this._writableState.writable = !!val; - } - }, - }, - writableFinished: { - get() { - return !!this._writableState?.finished; - }, - }, - writableObjectMode: { - get() { - return !!this._writableState?.objectMode; - }, - }, - writableBuffer: { - get() { - return this._writableState?.getBuffer(); - }, - }, - writableEnded: { - get() { - return !!this._writableState?.ending; - }, - }, - writableNeedDrain: { - get() { - const wState = this._writableState; - if (!wState) return false; - return !wState.destroyed && !wState.ending && wState.needDrain; - }, - }, - writableHighWaterMark: { - get() { - return this._writableState?.highWaterMark; - }, - }, - writableCorked: { - get() { - return this._writableState?.corked | 0; - }, - }, - writableLength: { - get() { - return this._writableState?.length; - }, + closed: { + get() { + return !!(this._writableState?.closed); + } + }, + destroyed: { + get() { + return !!(this._writableState?.destroyed); }, - writableAborted: { - enumerable: false, - get() { - return !!( - this._writableState.writable !== false && - (this._writableState.destroyed || this._writableState.errored) && - !this._writableState.finished - ); - }, + set(value) { + // Backward compatibility, the user is explicitly managing destroyed. + if (this._writableState) { + this._writableState.destroyed = value + } + } + }, + errored: { + enumerable: false, + get() { + return this._writableState?.errored || null; + } + }, + writable: { + get() { + const w = this._writableState + // w.writable === false means that this is part of a Duplex stream + // where the writable side was disabled upon construction. + // Compat. The user might manually disable writable side through + // deprecated setter. + return !!w && w.writable !== false && !w.destroyed && !w.errored && !w.ending && !w.ended; }, + set(val) { + // Backwards compatible. + if (this._writableState) { + this._writableState.writable = !!val; + } + } + }, + writableFinished: { + get() { + return !!(this._writableState?.finished); + } + }, + writableObjectMode: { + get() { + return !!(this._writableState?.objectMode); + } + }, + writableBuffer: { + get() { + return this._writableState?.getBuffer(); + } + }, + writableEnded: { + get() { + return !!(this._writableState?.ending); + } + }, + writableNeedDrain: { + get() { + const wState = this._writableState; + if (!wState) return false; + return !wState.destroyed && !wState.ending && wState.needDrain; + } + }, + writableHighWaterMark: { + get() { + return this._writableState?.highWaterMark; + } + }, + writableCorked: { + get() { + return this._writableState?.corked | 0; + } + }, + writableLength: { + get() { + return this._writableState?.length; + } + }, + writableAborted: { + enumerable: false, + get() { + return !!( + this._writableState.writable !== false && + (this._writableState.destroyed || this._writableState.errored) && + !this._writableState.finished + ) + } + } }); Writable.prototype.destroy = function (err, cb) { - const state = this._writableState; - - // Invoke pending callbacks. - if ( - !state.destroyed && - (state.bufferedIndex < state.buffered.length || state[kOnFinished].length) - ) { - process.nextTick(errorBuffer, state); - } - destroy.call(this, err, cb); - return this; -}; + const state = this._writableState; + + // Invoke pending callbacks. + if (!state.destroyed && (state.bufferedIndex < state.buffered.length || state[kOnFinished].length)) { + process.nextTick(errorBuffer, state); + } + destroy.call(this, err, cb); + return this; +} -Writable.prototype._undestroy = undestroy; +Writable.prototype._undestroy = undestroy Writable.prototype._destroy = function (err, cb) { - if (cb) cb(err); -}; + if (cb) cb(err); +} Writable.prototype[EventEmitter.captureRejectionSymbol] = function (err) { - this.destroy(err); -}; + this.destroy(err); +} Writable.fromWeb = function (writableStream, options) { - return newStreamWritableFromWritableStream(writableStream, options); -}; + return newStreamWritableFromWritableStream(writableStream, options) +} Writable.toWeb = function (streamWritable) { - return newWritableStreamFromStreamWritable(streamWritable); -}; + return newWritableStreamFromStreamWritable(streamWritable) +} diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.d.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.d.ts index d97761026..400179abc 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.d.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.d.ts @@ -11,7 +11,7 @@ export abstract class MIMEType { export abstract class MIMEParams { public constructor(); public delete(name: string): void; - public get(name: string): string | undefined; + public get(name: string): string|undefined; public has(name: string): boolean; public set(name: string, value: string): void; public entries(): Iterable; @@ -23,10 +23,7 @@ export const kResourceTypeInspect: unique symbol; export const ALL_PROPERTIES: 0; export const ONLY_ENUMERABLE: 1; -export function getOwnNonIndexProperties( - value: unknown, - filter: typeof ALL_PROPERTIES | typeof ONLY_ENUMERABLE -): PropertyKey[]; +export function getOwnNonIndexProperties(value: unknown, filter: typeof ALL_PROPERTIES | typeof ONLY_ENUMERABLE): PropertyKey[]; export const kPending: 0; export const kFulfilled: 1; @@ -102,6 +99,4 @@ export function isUint32Array(value: unknown): value is Uint32Array; export function isWeakMap(value: unknown): value is WeakMap; export function isWeakSet(value: unknown): value is WeakSet; export function isAnyArrayBuffer(value: unknown): value is ArrayBuffer | SharedArrayBuffer; -export function isBoxedPrimitive( - value: unknown -): value is Number | String | Boolean | BigInt | Symbol; +export function isBoxedPrimitive(value: unknown): value is Number | String | Boolean | BigInt | Symbol; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.ts index 13f506b0b..2821fd065 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/util.ts @@ -1,15 +1,7 @@ -import { - ALL_PROPERTIES as A_PROPERTIES, - ONLY_CONFIGURABLE, - ONLY_ENUMERABLE as O_ENUMERABLE, - ONLY_WRITABLE, - SKIP_STRINGS, - SKIP_SYMBOLS, - isArrayIndex, -} from "./internal_utils"; +import { ALL_PROPERTIES as A_PROPERTIES, ONLY_CONFIGURABLE, ONLY_ENUMERABLE as O_ENUMERABLE, ONLY_WRITABLE, SKIP_STRINGS, SKIP_SYMBOLS, isArrayIndex } from "./internal_utils"; export const kPending = 0; -export const kFulfilled = 1; +export const kFulfilled= 1; export const kRejected = 2; export const kResourceTypeInspect: unique symbol = Symbol.for("nodejs.util.inspect.custom"); @@ -44,9 +36,12 @@ export interface ProxyDetails { export function getOwnNonIndexProperties( // deno-lint-ignore ban-types obj: object, - filter: number + filter: number, ): (string | symbol)[] { - let allProperties = [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)]; + let allProperties = [ + ...Object.getOwnPropertyNames(obj), + ...Object.getOwnPropertySymbols(obj), + ]; if (Array.isArray(obj)) { allProperties = allProperties.filter((k) => !isArrayIndex(k)); @@ -238,18 +233,17 @@ export function isAnyArrayBuffer(value: unknown): value is ArrayBuffer | SharedA return false; } -export function isBoxedPrimitive( - value: unknown -): value is Number | String | Boolean | BigInt | Symbol { +export function isBoxedPrimitive(value: unknown): value is Number | String | Boolean | BigInt | Symbol { return false; } + export function getPromiseDetails(value: unknown): PromiseDetails | undefined { - return undefined; + return undefined } export function getProxyDetails(value: unknown): ProxyDetails | undefined { - return undefined; + return undefined } export function previewEntries(value: unknown): PreviewedEntries | undefined { @@ -259,3 +253,4 @@ export function previewEntries(value: unknown): PreviewedEntries | undefined { export function getConstructorName(value: unknown): string { return ""; } + diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/internal/validators.ts b/JS/wasm/crates/wasmjs-engine/shims/src/internal/validators.ts index f34d63533..58985a377 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/internal/validators.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/internal/validators.ts @@ -1,24 +1,31 @@ import { isArrayBufferView } from "./internal_types"; import { normalizeEncoding } from "./internal_utils"; -import { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE } from "./internal_errors"; +import { + ERR_INVALID_ARG_TYPE, + ERR_INVALID_ARG_VALUE, + ERR_OUT_OF_RANGE, +} from "./internal_errors"; // TODO(someday): Not current implementing parseFileMode, validatePort export const isInt32 = (value: any) => value === (value | 0); -export const isUint32 = (value: any) => value === value >>> 0; +export const isUint32 = (value: any) => value === (value >>> 0); export function validateBuffer(buffer: unknown, name = "buffer") { if (!isArrayBufferView(buffer)) { - throw new ERR_INVALID_ARG_TYPE(name, ["Buffer", "TypedArray", "DataView"], buffer); + throw new ERR_INVALID_ARG_TYPE( + name, + ["Buffer", "TypedArray", "DataView"], + buffer, + ); } -} +}; export function validateInteger( value: unknown, name: string, min = Number.MIN_SAFE_INTEGER, - max = Number.MAX_SAFE_INTEGER -) { + max = Number.MAX_SAFE_INTEGER) { if (typeof value !== "number") { throw new ERR_INVALID_ARG_TYPE(name, "number", value); } @@ -34,7 +41,7 @@ export interface ValidateObjectOptions { allowArray?: boolean; allowFunction?: boolean; nullable?: boolean; -} +}; export function validateObject(value: unknown, name: string, options?: ValidateObjectOptions) { const useDefaultOptions = options == null; @@ -44,11 +51,13 @@ export function validateObject(value: unknown, name: string, options?: ValidateO if ( (!nullable && value === null) || (!allowArray && Array.isArray(value)) || - (typeof value !== "object" && (!allowFunction || typeof value !== "function")) + (typeof value !== "object" && ( + !allowFunction || typeof value !== "function" + )) ) { throw new ERR_INVALID_ARG_TYPE(name, "Object", value); } -} +}; export function validateInt32(value: any, name: string, min = -2147483648, max = 2147483647) { if (!isInt32(value)) { @@ -78,7 +87,11 @@ export function validateUint32(value: unknown, name: string, positive?: boolean) } const min = positive ? 1 : 0; // 2 ** 32 === 4294967296 - throw new ERR_OUT_OF_RANGE(name, `>= ${min} && < 4294967296`, value); + throw new ERR_OUT_OF_RANGE( + name, + `>= ${min} && < 4294967296`, + value, + ); } if (positive && value === 0) { throw new ERR_OUT_OF_RANGE(name, ">= 1 && < 4294967296", value); @@ -106,8 +119,11 @@ export function validateBoolean(value: unknown, name: string) { export function validateOneOf(value: unknown, name: string, oneOf: any[]) { if (!Array.prototype.includes.call(oneOf, value)) { const allowed = Array.prototype.join.call( - Array.prototype.map.call(oneOf, (v) => (typeof v === "string" ? `'${v}'` : String(v))), - ", " + Array.prototype.map.call( + oneOf, + (v) => (typeof v === "string" ? `'${v}'` : String(v)), + ), + ", ", ); const reason = "must be one of: " + allowed; @@ -123,7 +139,7 @@ export function validateEncoding(data: unknown, encoding: string): void { throw new ERR_INVALID_ARG_VALUE( "encoding", encoding, - `is invalid for data of length ${length}` + `is invalid for data of length ${length}`, ); } } @@ -131,11 +147,13 @@ export function validateEncoding(data: unknown, encoding: string): void { export function validateAbortSignal(signal: unknown, name: string) { if ( signal !== undefined && - (signal === null || typeof signal !== "object" || !("aborted" in signal)) + (signal === null || + typeof signal !== "object" || + !("aborted" in signal)) ) { throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal); } -} +}; export function validateFunction(value: unknown, name: string) { if (typeof value !== "function") { @@ -168,4 +186,4 @@ export default { validateOneOf, validateString, validateUint32, -}; +}; \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/path.js b/JS/wasm/crates/wasmjs-engine/shims/src/path.js index f5f64f2c4..08cce9319 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/path.js +++ b/JS/wasm/crates/wasmjs-engine/shims/src/path.js @@ -1,4 +1,7 @@ -import { posix, win32 } from "./internal/internal_path"; +import { + posix, + win32, +} from './internal/internal_path'; const { resolve, @@ -34,8 +37,8 @@ export { win32, }; -export { default } from "./internal/internal_path"; -import process from "./internal/process"; +export { default } from './internal/internal_path' +import process from './internal/process'; globalThis.process = process; @@ -55,4 +58,4 @@ globalThis.path = { delimiter, posix, win32, -}; +} diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/path/posix.ts b/JS/wasm/crates/wasmjs-engine/shims/src/path/posix.ts index 7a16fe830..03168d917 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/path/posix.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/path/posix.ts @@ -1,3 +1,3 @@ -import { posix } from "../internal/internal_path"; +import { posix } from '../internal/internal_path'; export default posix; diff --git a/JS/wasm/crates/wasmjs-engine/shims/src/path/win32.ts b/JS/wasm/crates/wasmjs-engine/shims/src/path/win32.ts index f67ec9e71..440107305 100644 --- a/JS/wasm/crates/wasmjs-engine/shims/src/path/win32.ts +++ b/JS/wasm/crates/wasmjs-engine/shims/src/path/win32.ts @@ -1,3 +1,3 @@ -import { win32 } from "../internal/internal_path"; +import { win32 } from '../internal/internal_path'; export default win32; diff --git a/JS/wasm/crates/wasmjs-engine/src/main.rs b/JS/wasm/crates/wasmjs-engine/src/main.rs index afa620a1b..6ccb308f0 100644 --- a/JS/wasm/crates/wasmjs-engine/src/main.rs +++ b/JS/wasm/crates/wasmjs-engine/src/main.rs @@ -131,15 +131,71 @@ pub fn load_bindings(context: &JSContextRef, global: JSValueRef) -> Result<(), R invalid_export: "console_log".to_string(), })?; + global + .set_property( + "readBytes", + context + .wrap_callback(|_ctx, _this_arg, args| { + let path = args[0].to_string(); + match read_bytes(path.as_str()) { + Ok(result) => Ok(JSValue::String(result)), + Err(err) => { + let kind = match err { + FileError::NotFound => "File not found".to_string(), + FileError::InvalidPath => "Not allowed".to_string(), + }; + + Ok(JSValue::from_hashmap(HashMap::from([ + ("error", JSValue::Bool(true)), + ("type", JSValue::String(kind)), + ]))) + } + } + }) + .map_err(|_| RuntimeError::InvalidBinding { + invalid_export: "readBytes".to_string(), + })?, + ) + .map_err(|_| RuntimeError::InvalidBinding { + invalid_export: "readBytes".to_string(), + })?; + + global + .set_property( + "parseJsonnet", + context + .wrap_callback(|_ctx, _this_arg, args| { + let path = args[0].to_string(); + match parse_jsonnet(path.as_str()) { + Ok(result) => Ok(JSValue::String(result)), + Err(err) => { + let kind = match err { + FileError::NotFound => "File not found".to_string(), + FileError::InvalidPath => "Not allowed".to_string(), + }; + + Ok(JSValue::from_hashmap(HashMap::from([ + ("error", JSValue::Bool(true)), + ("type", JSValue::String(kind)), + ]))) + } + } + }) + .map_err(|_| RuntimeError::InvalidBinding { + invalid_export: "parseJsonnet".to_string(), + })?, + ) + .map_err(|_| RuntimeError::InvalidBinding { + invalid_export: "parseJsonnet".to_string(), + })?; Ok(()) } static POLYFILL: &str = include_str!("../shims/dist/index.js"); static POLYFILL_BUFFER: &str = include_str!("../shims/dist/buffer.js"); - static POLYFILL_PATH: &str = include_str!("../shims/dist/path.js"); - static POLYFILL_CRYPTO: &str = include_str!("../shims/dist/crypto.js"); +static ARAKOOJSONNET: &str = include_str!("../shims/dist/arakoo-jsonnet.js"); fn main() { let runtime = Runtime::default(); @@ -171,16 +227,19 @@ fn main() { let global = context.global_object().unwrap(); match load_bindings(context, global) { Ok(_) => {} - Err(e) => match e { - RuntimeError::InvalidBinding { invalid_export } => { - eprintln!("There was an error adding the '{invalid_export}' binding"); + Err(e) => { + match e { + RuntimeError::InvalidBinding { invalid_export } => { + eprintln!("There was an error adding the '{invalid_export}' binding"); + } } - }, + } } context.eval_module("buffer", &buffer).unwrap(); context.eval_module("crypto", &crypto).unwrap(); - + context.eval_module("arakoo-jsonnet", &ARAKOOJSONNET).unwrap(); + match context.eval_module("path", &path) { Ok(_) => {} Err(err) => eprintln!("Error loading the path shim: {err}"), diff --git a/JS/wasm/crates/wasmjs-engine/taskfile.yml b/JS/wasm/crates/wasmjs-engine/taskfile.yml index 26ac78188..69d28cf08 100644 --- a/JS/wasm/crates/wasmjs-engine/taskfile.yml +++ b/JS/wasm/crates/wasmjs-engine/taskfile.yml @@ -1,23 +1,23 @@ version: "3" tasks: - add:wasm32-wasi:target: rustup target add wasm32-wasi - build: - deps: - - add:wasm32-wasi:target - - build-shims - cmds: - - cargo build --target wasm32-wasi --release - - cp ./target/wasm32-wasi/release/wasmjs-engine.wasm ./ - build-shims: - deps: - - shims-install - dir: shims - cmds: - - echo pwd - - npm run build - shims-install: - dir: shims - cmds: - - pwd - - npm install + add:wasm32-wasi:target: rustup target add wasm32-wasi + build: + deps: + - add:wasm32-wasi:target + - build-shims + cmds: + - cargo build --target wasm32-wasi --release + - cp ./target/wasm32-wasi/release/wasmjs-engine.wasm ./ + build-shims: + deps: + - shims-install + dir: shims + cmds: + - echo pwd + - npm run build + shims-install: + dir: shims + cmds: + - pwd + - npm install \ No newline at end of file diff --git a/JS/wasm/crates/wasmjs-engine/wasmjs-engine.wasm b/JS/wasm/crates/wasmjs-engine/wasmjs-engine.wasm index 49b6851414c3e9743b378cdd45fd7eef6db47f58..a6796d523c65e6b41788e44499da21bbd383e95a 100755 GIT binary patch delta 562030 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�EJWe`-pX!UrEHKB6t<6v{<@Xj`F&eqU@-F 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 z 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 delta 884591 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

;T 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

^ri=nLOKTRL0JJkKhb%D#M_Wx)H= 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

    fFbS5*>~bWos0TCtZvugWRoexk5IQynj(N zmc-QxGnRBV8B01%$C7__D9Mvg(7(x@BJ;ThbMmw2MdmXAVl?&3hv|7aBeh>9l0(T| zZVzj&KjP$2a;SxfU+H^26kI?8oO}wrS8oe*5CI3Bc+!H^Y2U9ED$6`L`czOfz`s2D zR1}Y+Pr3}Q2J+~WE`qRK1Ymss)p{^iAAOQlVjX?@35yAl502J7=!5;DV=w+69(zgK z=QL5XLrXFKbU%k&E-wrE`f#JXEC^<;sviRHm@Ybk$WAi79+$yy;>A83eHwp(E7%Tt z+!pS-)OSWDs3n&ACifGa$cRi0pUw*X=t49O(8Xl1}5vJ7LwZEa@*E08r8# z4Sk89xEW!Z4Ej^K>+6_Pc!*4Yn)$-I#*ue|Yq1gdGpK zQo(2ixk$T@9glwaa0Tmrc(M(nAD(e1(Nwo6G(Y@GUDc`cOaWP?GqDwhKssq*}v}etPqa` zq+T?-x3hB{sQq=DWS6~r(~||G!2q67>=IeqPuQ#9Q{^VJbYGT5^Rx4A!0#GwGEE{9 zG9$fyfagMs?v9v!U1ibzy}|Q4zc+X$l2tk39<0!XRf+Szdjc9uE1u#fwndn%a@NGr z^VxStFs=AR3sw*CEKn$)SulA1K*8jmMtrw|wGls|;LvD;RO&lB1FY6nJZP&e*f6ZN zt%8e0?Yy<$Nf8l=b+F3-v@Ytga0R^=f5;~4i0n#H9%YFGBgn8-($Ck zH1-$h9jBG7GO9sqB(VmRaw+MTwiqMnNZmaU$%9f)-HWA1=#o4r^#FjG0Akzv-pvRv zWEhtjry;zYVXPJfV*#uNAa64^0w8HNEpIa(YQevAn^CfEt(J7VY*K zs|6;K?rJ8ek15zieE71dzrjkvESe2E zOgHdzk`ERuJ*dS-iZtZgDhSBm2lyKovUZh|fmIhzEcTxzPE!bj)rDB z=;yQR9utDK8ov2Sbq_KP^TL-h`T%ObK9>j3<2Xq&3z&kdLKgR~Bs9e#-Bnld?7@gHEvY3sK zbI)5NEjp3>Mea`yT%Z5FK95K$(e@9ZmxC@y1=9nj8iuRs|JNR!v%0+CFRvIyjs7PVj2`$5@77v< z-X~C-xY)6~QLI2*jYX8xF%!}LX^_z@*(b<8udEENmO8>n?VgC_S%UmSp}uTG+T4wG zfS6eY{oLO7zIqV5Ck$`V%=huf? z_T-KJ)I5cfM%uMtU}~`2wIlw@-<$ZWgta=!Wtap>r!Unb_*1>4JfjiLQ;W7My#M;$ zQT-wS?*GFjgzt;mov7OmwVOHUGpvoUTgCod_N?cHkaf<568zAoK)hrR{8iK22CQD( zgqeYE$|I4&auT;-RmuHOI|)W6zYOTe#R6jKCH8qZto*%z47(Z&5o_gpTPc{997{Dz zY*dXeE&JOpB2lRllrupY9fbT{jlYUn)dQb_8U5!=VE<8Lm}3_y{eCAOy#mwHVRmVO z&^hpzsZ~c}x3C%XWimW0e%26;n@#@YFC1}sOW-+$2(LF#c7NMhLj0UVb>eE|_S?Dw zQe*wIs5)=5s&fEV3qHZ%TvzAGrYN~cFRODaJyKz$whSU!n>RfY*5-bQleIa|Ld4qo z-Z_szek!}J&S5Hnsm_BG0@krgNto_uVcpll_R?Y5T;|jK$)(1S60}(|p{8i5C8mtbC zTL$^HLfinBEN^vq9l!={UX0ZGKqOyQ5Kn|PdOhOg%L?DFj1b<=zW0HG>5IH}rQYL@ zhw+5@u)@;E)%q6^>YC|$Dh&sp%(I0mgzfHiNF{etGzrUh6V6u%dLky6W5eAG$$u$= z7>r_}-A@iu1Y?8;2d%wP3L$O2q0&1_5g?qnKbP3wf-~Xkte!%}Nn>cGAt8Afx|Jb8 z*d{?(k*Equ1oFBZXcY4`q|Up|7JN`ea<&C0o`!;JLFAaNOA|S|{wXo zs+>x!7RO)P9iQ`AZrf?`c=JEr3 gP6X&CiY^Ab6H%DI?XQmT+0)6F2WAr0VU;5e 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�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 diff --git a/JS/wasm/crates/wasmjs-runtime/Cargo.lock b/JS/wasm/crates/wasmjs-runtime/Cargo.lock index 9477b9411..2beed09ee 100644 --- a/JS/wasm/crates/wasmjs-runtime/Cargo.lock +++ b/JS/wasm/crates/wasmjs-runtime/Cargo.lock @@ -1418,6 +1418,26 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "jsonnet-rs" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b396bdfc3ae94965555c9ec3efa2214e5f3921545a943ef9fc9873ff5e4723" +dependencies = [ + "jsonnet-sys", + "libc", +] + +[[package]] +name = "jsonnet-sys" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02347cbdf34234f30f0d92f0f8f678a15883bd5e1e4b3def4ed4a14f691d9add" +dependencies = [ + "cc", + "libc", +] + [[package]] name = "language-tags" version = "0.3.2" @@ -2766,6 +2786,7 @@ dependencies = [ "blake3", "clap", "http", + "jsonnet-rs", "lazy_static", "regex", "reqwest", diff --git a/JS/wasm/crates/wasmjs-runtime/Cargo.toml b/JS/wasm/crates/wasmjs-runtime/Cargo.toml index a675c8278..3f6e47f8d 100644 --- a/JS/wasm/crates/wasmjs-runtime/Cargo.toml +++ b/JS/wasm/crates/wasmjs-runtime/Cargo.toml @@ -33,3 +33,4 @@ wiggle = "15.0.0" thiserror = "1.0" tracing = "0.1.40" semver = "^0.10.0" +jsonnet-rs = "0.17.0" diff --git a/JS/wasm/crates/wasmjs-runtime/src/bindings.rs b/JS/wasm/crates/wasmjs-runtime/src/bindings.rs index 3d748c6eb..591fcbd0c 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/bindings.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/bindings.rs @@ -1,4 +1,5 @@ use actix_web::http::Uri; +use jsonnet::JsonnetVm; use reqwest::Method; use serde::Deserialize; use tokio::runtime::Builder; @@ -21,7 +22,7 @@ impl GuestErrorType for ArakooStatus { } } -use self::{http::{Http, HttpRequest, HttpRequestError, HttpResponse, HttpError, HttpMethod}, types::ArakooStatus}; +use self::{http::{Http, HttpRequest, HttpRequestError, HttpResponse, HttpError, HttpMethod, FileError}, types::ArakooStatus}; #[derive(Deserialize, Clone)] #[serde(default)] @@ -51,7 +52,7 @@ pub struct HttpBindings { pub http_config: HttpRequestsConfig, } -impl From for reqwest::Method { +impl From for Method { fn from(value: HttpMethod) -> Self { match value { HttpMethod::Get => Method::GET, @@ -191,4 +192,72 @@ impl Http for HttpBindings { }), } } + + fn read_bytes(&mut self, path: &str) -> Result { + // read the file from the path and return the bytes + // if the file does not exist, return FileError::NotFound + let path = path.to_owned(); + let thread_result = std::thread::spawn(move || { + Builder::new_current_thread() + .enable_all() + .build() + .unwrap() + .block_on(async { + let bytes = tokio::fs::read(path).await; + match bytes { + Ok(bytes) => + Ok(std::str::from_utf8(&bytes).unwrap().to_string()), + Err(_) => { + Err(FileError::NotFound) + } + } + }) + }) + .join(); + + match thread_result { + Ok(res) => match res { + Ok(res) => Ok(res), + Err(err) => Err(err), + }, + Err(_) => Err(FileError::NotFound), + } + } + + + fn parse_jsonnet(&mut self, file: &str) -> Result { + parse_jsonnet(file) + } +} + + +pub fn parse_jsonnet(file: &str) -> Result { + let file = file.to_owned(); + let thread_result = std::thread::spawn(move || { + Builder::new_current_thread() + .enable_all() + .build() + .unwrap() + .block_on(async { + let mut vm = JsonnetVm::new(); + let json = vm.evaluate_file(&file); + + match json { + Ok(json) => Ok(json.to_string()), + Err(e) => { + println!("Error: {}", e); + Err(FileError::NotFound) + }, + } + }) + }) + .join(); + + match thread_result { + Ok(res) => match res { + Ok(res) => Ok(res), + Err(err) => Err(err), + }, + Err(_) => Err(FileError::NotFound), + } } diff --git a/JS/wasm/crates/wasmjs-runtime/src/handlers.rs b/JS/wasm/crates/wasmjs-runtime/src/handlers.rs index ec7a7416b..e70c556e3 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/handlers.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/handlers.rs @@ -1,17 +1,21 @@ -use crate::{io::WasmOutput, routes::WORKERS, server::AppData}; +use std::{ + io::{Error, ErrorKind}, + path::{Component, Path, PathBuf}, +}; + use actix_files::NamedFile; use actix_web::{ http::StatusCode, web::{Bytes, Data}, HttpRequest, HttpResponse, }; -use std::{ - io::{Error, ErrorKind}, - path::{Component, Path, PathBuf}, -}; + use std::net::{IpAddr, Ipv4Addr}; use std::str::FromStr; use crate::geolocation::GeolocationData; +use crate::io::WasmOutput; +use crate::routes::WORKERS; +use crate::server::AppData; fn clean_up_path(uri: &str) -> PathBuf { let path = PathBuf::from_iter(uri.split('/')); diff --git a/JS/wasm/crates/wasmjs-runtime/src/io.rs b/JS/wasm/crates/wasmjs-runtime/src/io.rs index 4058e9f90..c08511e3d 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/io.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/io.rs @@ -1,9 +1,10 @@ +use std::{collections::HashMap, fmt::Debug}; + use actix_web::{ http::{header::HeaderMap, StatusCode, Uri}, HttpRequest, }; use serde::{Deserialize, Serialize}; -use std::{collections::HashMap, fmt::Debug}; use serde_json::{Map, Value as SerdeValue}; use crate::geolocation::GeolocationData; diff --git a/JS/wasm/crates/wasmjs-runtime/src/routes.rs b/JS/wasm/crates/wasmjs-runtime/src/routes.rs index c2718dd12..7cebe67f9 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/routes.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/routes.rs @@ -1,14 +1,17 @@ +use std::{ + collections::HashMap, + ffi::OsStr, + path::{Component, Path, PathBuf}, + str::FromStr, + sync::{Arc, RwLock}, +}; + use lazy_static::lazy_static; use regex::Regex; -use std::path::{Path, PathBuf}; -use std::str::FromStr; -use std::sync::RwLock; -use std::{collections::HashMap, ffi::OsStr, path::Component, sync::Arc}; use wax::{Glob, WalkEntry}; use crate::ServeArgs; -use crate::store::STORE_FOLDER; -use crate::workers::Worker; +use crate::{store::STORE_FOLDER, workers::Worker}; pub struct Files<'t> { root: PathBuf, diff --git a/JS/wasm/crates/wasmjs-runtime/src/server.rs b/JS/wasm/crates/wasmjs-runtime/src/server.rs index f24e78ea9..7d9e0aeb6 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/server.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/server.rs @@ -1,4 +1,3 @@ -use std::fmt::Debug; use std::path::PathBuf; use actix_web::{ diff --git a/JS/wasm/crates/wasmjs-runtime/src/store.rs b/JS/wasm/crates/wasmjs-runtime/src/store.rs index 744576cf7..3b72b7b97 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/store.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/store.rs @@ -1,9 +1,10 @@ -use anyhow::Result; use std::{ fs, path::{Path, PathBuf}, }; +use anyhow::Result; + pub const STORE_FOLDER: &str = ".wasmjs"; pub struct Store { diff --git a/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi.rs b/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi.rs index f0fbdddfb..834ccf472 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi.rs @@ -13,7 +13,6 @@ pub struct Session { } impl Session { - pub fn geolocation_lookup(&self, addr: &IpAddr) -> Option { self.geolocation.lookup(addr).map(|data| data.to_string()) } diff --git a/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi/geo_impl.rs b/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi/geo_impl.rs index 58fefa2ae..ab5d39114 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi/geo_impl.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/wiggle_abi/geo_impl.rs @@ -1,7 +1,3 @@ -//! edge_geo` hostcall implementations. - - - use crate::bindings::types::ArakooStatus; #[derive(Debug, thiserror::Error)] diff --git a/JS/wasm/crates/wasmjs-runtime/src/workers.rs b/JS/wasm/crates/wasmjs-runtime/src/workers.rs index fd8fd7b19..cbe403958 100644 --- a/JS/wasm/crates/wasmjs-runtime/src/workers.rs +++ b/JS/wasm/crates/wasmjs-runtime/src/workers.rs @@ -3,16 +3,18 @@ use crate::config::{ArakooConfig, Config}; use crate::io::{WasmInput, WasmOutput}; use crate::runtime::{init_runtime, CtxBuilder, Runtime}; use crate::bindings::http; +use std::{ + collections::HashMap, + io::Cursor, + path::{Path, PathBuf}, +}; + use actix_web::HttpRequest; use sha256::digest as sha256_digest; -use std::path::PathBuf; -use std::{collections::HashMap, path::Path}; -use wasmtime::Linker; -use wasmtime::{Config as WasmtimeConfig, Engine, Module, Store}; +use wasmtime::{Config as WasmtimeConfig, Engine, Linker, Module, Store}; use wasmtime_wasi::{ambient_authority, Dir, WasiCtxBuilder}; use anyhow::Result; -use std::io::Cursor; use wasi_common::pipe::{ReadPipe, WritePipe}; use crate::ServeArgs; use crate::geolocation::GeolocationData; diff --git a/JS/wasm/examples/ec-wasmjs-hono/build.js b/JS/wasm/examples/ec-wasmjs-hono/build.js index 50f5f006a..64bbadaec 100644 --- a/JS/wasm/examples/ec-wasmjs-hono/build.js +++ b/JS/wasm/examples/ec-wasmjs-hono/build.js @@ -8,6 +8,9 @@ build({ format: "esm", target: "esnext", platform: "node", + external:[ + "arakoo-jsonnet" + ] }).catch((error) => { console.error(error); process.exit(1); diff --git a/JS/wasm/examples/ec-wasmjs-hono/package-lock.json b/JS/wasm/examples/ec-wasmjs-hono/package-lock.json index cf6c18ec9..ae5bd0d88 100644 --- a/JS/wasm/examples/ec-wasmjs-hono/package-lock.json +++ b/JS/wasm/examples/ec-wasmjs-hono/package-lock.json @@ -7,6 +7,7 @@ "name": "hono", "dependencies": { "@hono/node-server": "^1.3.1", + "arakoo-jsonnet": "file:../../types/jsonnet", "axios": "^1.6.2", "crypto": "^1.0.1", "http": "^0.0.1-security", @@ -18,6 +19,14 @@ "hono": "^3.9" } }, + "../../types/jsonnet": { + "version": "0.1.0", + "hasInstallScript": true, + "license": "ISC", + "devDependencies": { + "cargo-cp-artifact": "^0.1" + } + }, "node_modules/@esbuild/android-arm": { "version": "0.19.5", "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.5.tgz", @@ -387,6 +396,10 @@ "node": ">=16" } }, + "node_modules/arakoo-jsonnet": { + "resolved": "../../types/jsonnet", + "link": true + }, "node_modules/asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", diff --git a/JS/wasm/examples/ec-wasmjs-hono/package.json b/JS/wasm/examples/ec-wasmjs-hono/package.json index 49e60ff54..08f95e85d 100644 --- a/JS/wasm/examples/ec-wasmjs-hono/package.json +++ b/JS/wasm/examples/ec-wasmjs-hono/package.json @@ -14,6 +14,7 @@ "@hono/node-server": "^1.3.1", "axios": "^1.6.2", "crypto": "^1.0.1", + "arakoo-jsonnet": "file:../../types/jsonnet", "http": "^0.0.1-security", "stream": "^0.0.2" } diff --git a/JS/wasm/types/jsonnet/.gitignore b/JS/wasm/types/jsonnet/.gitignore new file mode 100644 index 000000000..8ea5b111e --- /dev/null +++ b/JS/wasm/types/jsonnet/.gitignore @@ -0,0 +1,6 @@ +target +index.node +**/node_modules +**/.DS_Store +npm-debug.log* + diff --git a/JS/wasm/types/jsonnet/Cargo.lock b/JS/wasm/types/jsonnet/Cargo.lock new file mode 100644 index 000000000..bd343e56a --- /dev/null +++ b/JS/wasm/types/jsonnet/Cargo.lock @@ -0,0 +1,192 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "arakoo-jsonnet" +version = "0.1.0" +dependencies = [ + "jsonnet-rs", + "neon", +] + +[[package]] +name = "cc" +version = "1.0.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +dependencies = [ + "libc", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "jsonnet-rs" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b396bdfc3ae94965555c9ec3efa2214e5f3921545a943ef9fc9873ff5e4723" +dependencies = [ + "jsonnet-sys", + "libc", +] + +[[package]] +name = "jsonnet-sys" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02347cbdf34234f30f0d92f0f8f678a15883bd5e1e4b3def4ed4a14f691d9add" +dependencies = [ + "cc", + "libc", +] + +[[package]] +name = "libc" +version = "0.2.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4" + +[[package]] +name = "libloading" +version = "0.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "351a32417a12d5f7e82c368a66781e307834dae04c6ce0cd4456d52989229883" +dependencies = [ + "cfg-if", + "winapi", +] + +[[package]] +name = "neon" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28e15415261d880aed48122e917a45e87bb82cf0260bb6db48bbab44b7464373" +dependencies = [ + "neon-build", + "neon-macros", + "neon-runtime", + "semver", + "smallvec", +] + +[[package]] +name = "neon-build" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bac98a702e71804af3dacfde41edde4a16076a7bbe889ae61e56e18c5b1c811" + +[[package]] +name = "neon-macros" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7288eac8b54af7913c60e0eb0e2a7683020dffa342ab3fd15e28f035ba897cf" +dependencies = [ + "quote", + "syn", + "syn-mid", +] + +[[package]] +name = "neon-runtime" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4676720fa8bb32c64c3d9f49c47a47289239ec46b4bdb66d0913cc512cb0daca" +dependencies = [ + "cfg-if", + "libloading", + "smallvec", +] + +[[package]] +name = "proc-macro2" +version = "1.0.71" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75cb1540fadbd5b8fbccc4dddad2734eba435053f725621c070711a14bb5f4b8" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "semver" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" +dependencies = [ + "semver-parser", +] + +[[package]] +name = "semver-parser" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" + +[[package]] +name = "smallvec" +version = "1.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970" + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn-mid" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fea305d57546cc8cd04feb14b62ec84bf17f50e3f7b12560d7bfa9265f39d9ed" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/JS/wasm/types/jsonnet/Cargo.toml b/JS/wasm/types/jsonnet/Cargo.toml new file mode 100644 index 000000000..0b5163643 --- /dev/null +++ b/JS/wasm/types/jsonnet/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "arakoo-jsonnet" +version = "0.1.0" +license = "ISC" +edition = "2018" +exclude = ["index.node"] + +[lib] +crate-type = ["cdylib"] +path = "src/lib.rs" +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +jsonnet-rs = "0.17" + +[dependencies.neon] +version = "0.10" +default-features = false +features = ["napi-6"] diff --git a/JS/wasm/types/jsonnet/package-lock.json b/JS/wasm/types/jsonnet/package-lock.json new file mode 100644 index 000000000..369f0ebff --- /dev/null +++ b/JS/wasm/types/jsonnet/package-lock.json @@ -0,0 +1,26 @@ +{ + "name": "arakoo-jsonnet", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "arakoo-jsonnet", + "version": "0.1.0", + "hasInstallScript": true, + "license": "ISC", + "devDependencies": { + "cargo-cp-artifact": "^0.1" + } + }, + "node_modules/cargo-cp-artifact": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/cargo-cp-artifact/-/cargo-cp-artifact-0.1.8.tgz", + "integrity": "sha512-3j4DaoTrsCD1MRkTF2Soacii0Nx7UHCce0EwUf4fHnggwiE4fbmF2AbnfzayR36DF8KGadfh7M/Yfy625kgPlA==", + "dev": true, + "bin": { + "cargo-cp-artifact": "bin/cargo-cp-artifact.js" + } + } + } +} diff --git a/JS/wasm/types/jsonnet/package.json b/JS/wasm/types/jsonnet/package.json new file mode 100644 index 000000000..9ff3eeada --- /dev/null +++ b/JS/wasm/types/jsonnet/package.json @@ -0,0 +1,25 @@ +{ + "name": "arakoo-jsonnet", + "version": "0.1.0", + "description": "", + "main": "index.node", + "scripts": { + "build": "cargo-cp-artifact -nc index.node -- cargo build --message-format=json-render-diagnostics", + "build-debug": "npm run build --", + "build-release": "npm run build -- --release", + "install": "npm run build-release", + "test": "cargo test", + "preinstall": "npm install cargo-cp-artifact --no-save" + }, + "author": "", + "exports": { + ".": { + "require": "./src/index.js", + "default": "./src/module.mjs" + } + }, + "license": "ISC", + "devDependencies": { + "cargo-cp-artifact": "^0.1" + } +} diff --git a/JS/wasm/types/jsonnet/src/index.d.ts b/JS/wasm/types/jsonnet/src/index.d.ts new file mode 100644 index 000000000..c08e25f03 --- /dev/null +++ b/JS/wasm/types/jsonnet/src/index.d.ts @@ -0,0 +1 @@ +export function parseJsonnet(filename: string): Promise; diff --git a/JS/wasm/types/jsonnet/src/index.js b/JS/wasm/types/jsonnet/src/index.js new file mode 100644 index 000000000..057355a78 --- /dev/null +++ b/JS/wasm/types/jsonnet/src/index.js @@ -0,0 +1,5 @@ +const {parseJsonnet} = require("../index.node") + +module.exports = { + parseJsonnet, +}; diff --git a/JS/wasm/types/jsonnet/src/lib.rs b/JS/wasm/types/jsonnet/src/lib.rs new file mode 100644 index 000000000..70aa202fc --- /dev/null +++ b/JS/wasm/types/jsonnet/src/lib.rs @@ -0,0 +1,27 @@ +use std::fs; + +use neon::prelude::*; + +use jsonnet::JsonnetVm; + +pub fn parse_jsonnet( + mut cx: FunctionContext, +) -> JsResult { + let path: String = cx.argument::(0)?.value(&mut cx); + let mut vm = JsonnetVm::new(); + let snippet = fs::read_to_string(path).unwrap(); + let output = vm.evaluate_snippet("snippet", &snippet); + let output = match output { + Ok(output) => output, + Err(e) => { + return cx.throw_error(format!("Error: {}", e)); + } + }; + Ok(cx.string(output.to_string())) +} + +#[neon::main] +fn main(mut cx: ModuleContext) -> NeonResult<()> { + cx.export_function("parseJsonnet", parse_jsonnet)?; + Ok(()) +} diff --git a/JS/wasm/types/jsonnet/src/module.mjs b/JS/wasm/types/jsonnet/src/module.mjs new file mode 100644 index 000000000..5ea50ab49 --- /dev/null +++ b/JS/wasm/types/jsonnet/src/module.mjs @@ -0,0 +1,7 @@ +import parseJson from "./index.js" + +const {parseJsonnet} = parseJson; + +export { + parseJsonnet, +}; diff --git a/JS/wasm/types/jsonnet/tsconfig.json b/JS/wasm/types/jsonnet/tsconfig.json new file mode 100644 index 000000000..c97a99990 --- /dev/null +++ b/JS/wasm/types/jsonnet/tsconfig.json @@ -0,0 +1,15 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": ["es6"], + "strict": true, + "baseUrl": ".", + "paths": { "arakoo-jsonnet": ["."] } + }, + "typedocOptions": { + "entryPoints": ["index.d.ts"], + "out": "../docs", + "excludeExternals": true + }, + "include": ["."] + }