diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e58b851..cc3a00b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -27,6 +27,7 @@ jobs: - windows-latest node-version: - 26.5.1 + - 26.8.1 - 26.x steps: @@ -41,6 +42,12 @@ jobs: - name: Install development dependencies run: npm ci + - name: Verify Node capability policy + run: npm run test:node-capabilities + + - name: Verify capability candidate generation + run: npm run generate:node-capability-candidate > capability-candidate.json + - name: Test run: npm test diff --git a/README.md b/README.md index 82bfa50..cb3cb5e 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ Each worker starts with Node's Permission Model enabled. Source-string workers r ## Requirements -- Node.js 26.5.1 through the current Node.js 26.x release (`process.permission.drop()` and security fixes in 26.5.1 are required). Unsupported runtimes fail closed during module initialization with `ERR_SECURE_EVAL_UNSUPPORTED_RUNTIME`. Future major releases require a new hardening review before support is declared. +- Node.js 26.5.1 through the current Node.js 26.x release (`process.permission.drop()` and security fixes in 26.5.1 are required). Unsupported runtimes fail closed during module initialization with `ERR_SECURE_EVAL_UNSUPPORTED_RUNTIME`. A Node 26 update with an unreviewed built-in identity or export surface fails worker startup; future major releases require a new hardening review before support is declared. See the [Node capability policy](docs/node-capability-policy.md). - No permission flags are required when the host uses Node's default mode. If the host itself runs with `--permission`, it must include `--allow-worker`. Path-based execution additionally requires host read permission for the entry/root and read/write permission for the operating-system temporary directory used to create and remove the private snapshot. Each sandbox worker is started with its own reviewed `execArgv`. ## Installation @@ -113,7 +113,7 @@ console.log(await component.request('hello')) // { echo: 'hello' } await component.terminate() ``` -Module source must be self-contained ESM with a default setup-function export. It is imported from an in-memory `data:` URL after permissions are dropped. Built-in imports are permitted subject to the Permission Model, but relative files, package imports, and filesystem module paths are not resolved from source strings. Use the path APIs below or bundle authorized dependencies on the trusted host as described in [`docs/module-dependencies.md`](docs/module-dependencies.md). +Module source must be self-contained ESM with a default setup-function export. It is imported from an in-memory `data:` URL after permissions are dropped. Built-in imports are permitted only when approved by the [Node capability policy](docs/node-capability-policy.md), and remain subject to module-specific attenuation and the Permission Model; relative files, package imports, and filesystem module paths are not resolved from source strings. Use the path APIs below or bundle authorized dependencies on the trusted host as described in [`docs/module-dependencies.md`](docs/module-dependencies.md). ### Local module files @@ -289,10 +289,10 @@ Errors originating from execution use this class and have a machine-readable `co - Do not place secrets in `worker_threads.setEnvironmentData()`: Node clones global worker environment data into new workers independently of `WorkerOptions.env`. This module blocks the public getter, heap-snapshot APIs, and `v8.queryObjects()`, but avoiding the secret entirely is safer against future or internal APIs. - The token-recovery technique used by [Heapjack](https://www.accomplish.ai/blog/escaping-the-openai-codex-sandbox-twice/) does not provide a command path here. Host capabilities run in a different V8 isolate; ordinary stdout is discarded rather than parsed as control traffic; and the worker uses a private `MessageChannel` plus native-backed HMAC `KeyObject`s instead of JavaScript bearer-token strings. The trusted bootstrap and guest still share the worker isolate, so before guest execution the module also denies every callable V8 snapshot/object-query namespace and both inspector APIs exposed by the supported runtime, failing worker startup if those surfaces cannot be replaced. This protects against the published Heapjack technique, not against a future Node/V8 vulnerability or native memory-safety failure; use the outer OS boundary described above for hostile multi-tenant code. - Both execution modes close and hide `parentPort`, freeze the private channel's privileged prototype chain, and authenticate serialized payloads with per-session HMAC keys and monotonic sequence numbers. Capturing or replaying a port cannot forge control traffic. Captured descriptor operations inspect each protocol field and untrusted error field as an own data property; missing fields never fall through to inherited properties, and metadata accessors are not invoked. The intrinsic stack formatter is used only for verified native stack shapes while global `Error` remains an own data property resolving to the captured constructor and the original `Error.prepareStackTrace` descriptor remains unchanged; otherwise `remoteStack` is omitted. Parser errors created synchronously by captured Node APIs are normalized before guest execution so useful source locations remain available without treating later guest accessors as trusted. Ongoing ordinary reads are limited to private lexical bookkeeping records whose complete own data-property shapes are created by the bootstrap, frozen null-prototype deferred records, and `workerData` whose own security configuration, manifests, and nested policies are frozen before guest execution; the guest input remains intentionally mutable but is never used as trusted bookkeeping. -- Before guest execution, the bootstrap disables known same-process escape surfaces not covered by permissions: existing-descriptor access through public modules, including undocumented child-process IPC adoption; WASI and FFI; DNS and legacy network-module aliases; global `fetch`/`WebSocket`; accessor-exported stream constructors; and undocumented native bindings. It also disables asynchronous module-loader registration; `node:sqlite`; OpenSSL engine/FIPS mutation and secure-heap telemetry; trace/QUIC built-ins (explicitly denied when available and otherwise left unavailable without enabling runtime flags); process signaling, reports, and high-resolution host-lifetime clocks; process priority mutation; guest-facing V8 and performance hooks, serializers, profilers, snapshot callbacks, flag mutation, and object queries; async hooks; BroadcastChannel, Web Locks, cross-thread messaging, inherited worker environment data, and host identity/resource metadata APIs. The only guest-visible high-resolution clocks are worker-bootstrap-relative: a frozen null-prototype performance object shared by the global and built-in aliases exposes monotonic `now()`, `timeOrigin: 0`, and `nodeTiming: null`, while `Event.prototype.timeStamp` and inherited event timestamps use the same relative baseline. The original Performance constructors, prototypes, and observer paths are unavailable. Guest `argv`, current-directory reporting, executable arguments, executable path, process IDs, process title, and global module search paths are replaced with fixed or empty virtual values. Eval-wrapper `require`, `module`, `exports`, `__filename`, and `__dirname` globals are removed; CommonJS modules inside a staged local tree retain only root-confined lexical loading and resolver paths. The read-only `v8.startupSnapshot.isBuildingSnapshot()` probe remains available because Node's TypeScript erasure depends on it; callable V8 capabilities are otherwise denied. Node exposes `process.argv0` as a non-configurable worker property, so it remains visible through global, ESM, CommonJS, and `process.getBuiltinModule()` aliases; launch the host with a non-sensitive `argv0` value when this metadata matters. +- Before guest execution, the bootstrap verifies a reviewed fail-closed Node built-in identity/export manifest, installs a trusted synchronous resolve hook, and independently guards `_load()` and `process.getBuiltinModule()`. Unapproved built-ins fail through static and dynamic ESM, CommonJS, VM default-loader, and direct retrieval paths. Approved modules are either intentionally available, mode-dependent, or attenuated. The bootstrap then disables known same-process escape surfaces not covered by permissions: existing-descriptor access through public modules, including undocumented child-process IPC adoption; WASI and FFI; DNS and legacy network-module aliases; global `fetch`/`WebSocket`; accessor-exported stream constructors; and undocumented native bindings. It also disables asynchronous module-loader registration; `node:sqlite`; OpenSSL engine/FIPS mutation and secure-heap telemetry; trace/QUIC built-ins (explicitly denied when available and otherwise left unavailable without enabling runtime flags); process signaling, reports, and high-resolution host-lifetime clocks; process priority mutation; guest-facing V8 and performance hooks, serializers, profilers, snapshot callbacks, flag mutation, and object queries; async hooks; BroadcastChannel, Web Locks, cross-thread messaging, inherited worker environment data, and host identity/resource metadata APIs. The only guest-visible high-resolution clocks are worker-bootstrap-relative: a frozen null-prototype performance object shared by the global and built-in aliases exposes monotonic `now()`, `timeOrigin: 0`, and `nodeTiming: null`, while `Event.prototype.timeStamp` and inherited event timestamps use the same relative baseline. The original Performance constructors, prototypes, and observer paths are unavailable. Guest `argv`, current-directory reporting, executable arguments, executable path, process IDs, process title, and global module search paths are replaced with fixed or empty virtual values. Eval-wrapper `require`, `module`, `exports`, `__filename`, and `__dirname` globals are removed; CommonJS modules inside a staged local tree retain only root-confined lexical loading and resolver paths. The read-only `v8.startupSnapshot.isBuildingSnapshot()` probe remains available because Node's TypeScript erasure depends on it; callable V8 capabilities are otherwise denied. Node exposes `process.argv0` as a non-configurable worker property, so it remains visible through global, ESM, CommonJS, and `process.getBuiltinModule()` aliases; launch the host with a non-sensitive `argv0` value when this metadata matters. - Host functions are authority grants. They must validate and authorize every argument, constrain outputs, and avoid exposing generic filesystem or network primitives when a narrower business operation is possible. - A timed-out worker is sent a termination request, but Worker resource limits do not constrain `ArrayBuffer`, WebAssembly, native allocations, aggregate CPU, all libuv-thread-pool work, or process-wide out-of-memory failure. Uninterruptible native work can continue after the public termination promises settle with a termination error; its admission slot remains occupied until the actual worker exit. Host functions that ignore their abort signal may also continue host-side work after termination. -- JavaScript taming is additional defense in depth, not a substitute for an OS boundary. Future Node APIs, undocumented internals, native/runtime vulnerabilities, or process-wide behavior can invalidate it. Run adversarial multi-tenant code in a separately sandboxed process or container. +- JavaScript taming is additional defense in depth, not a substitute for an OS boundary. Unknown built-in IDs, top-level exports, reviewed direct nested objects, and exported constructor/prototype changes now fail closed, but semantic changes to existing APIs, APIs reachable only through native accessors, undocumented internals, native/runtime vulnerabilities, or process-wide behavior can still invalidate the review. Run adversarial multi-tenant code in a separately sandboxed process or container. ## Development @@ -300,6 +300,7 @@ Errors originating from execution use this class and have a machine-readable `co npm ci npm test npm run test:coverage +npm run test:node-capabilities npm run test:types npm run test:package ``` diff --git a/TODO.md b/TODO.md index ffb32e5..2cade81 100644 --- a/TODO.md +++ b/TODO.md @@ -144,8 +144,10 @@ features. These remain intentionally open because they are release-by-release requirements rather than one-time deliverables. -- [ ] Run the complete test suite on Node.js 26.5.1 and current 26.x for every - security-sensitive change. +- [ ] Run the complete test suite and `npm run test:node-capabilities` on + Node.js 26.5.1, the reviewed 26.8 API boundary, and current 26.x for every security-sensitive change. Review + every identity/export diff before updating the manifest; never auto-accept a + new runtime surface. - [ ] Add exploit-focused regression coverage for callable accessors, aliases, prototype-reachable constructors, inherited descriptors, native bindings, runtime introspection, and alternate execution contexts. diff --git a/docs/module-dependencies.md b/docs/module-dependencies.md index 590aed6..ea3c459 100644 --- a/docs/module-dependencies.md +++ b/docs/module-dependencies.md @@ -122,7 +122,11 @@ path and package authorization, graph limits, cancellation, and final output limits. Review bundler transformations and runtime helpers as executable guest code. Bundling does not make a dependency trusted. -Do not implement either model with `module.register()`, `registerHooks()`, -`--experimental-loader`, process-wide loader hooks, guest-provided resolvers, -or another VM/worker execution context. Loader hooks can execute outside this -worker's permission-drop and hardening sequence. +Do not implement either model with guest-controlled `module.register()`, +`registerHooks()`, `--experimental-loader`, process-wide loader hooks, +guest-provided resolvers, or another VM/worker execution context. Asynchronous +loader hooks can execute outside this worker's permission-drop and hardening +sequence. The bootstrap installs one private synchronous resolve hook after +permission drop and hardening solely to enforce the reviewed built-in-module +policy; guest registration APIs remain disabled. See +[`node-capability-policy.md`](node-capability-policy.md). diff --git a/docs/node-capability-policy.md b/docs/node-capability-policy.md new file mode 100644 index 0000000..c36b34b --- /dev/null +++ b/docs/node-capability-policy.md @@ -0,0 +1,185 @@ +# Node capability policy + +## Decision + +`secure-eval-worker` uses a reviewed, fail-closed policy for Node built-in modules in addition to Node's Permission Model and the existing API attenuation. + +The policy is machine-readable in `src/node-capability-policy.js`. Every built-in reported by the supported Node runtimes has one disposition: + +- **Allowed**: intentionally available as a general computation library. +- **Attenuated**: importable for compatibility, but authority-bearing exports are replaced, virtualized, or constrained before guest execution. +- **Mode-dependent**: unavailable to source-string workers and attenuated to staged-root reads for local-file workers. +- **Denied**: resolution fails with `ERR_ACCESS_DENIED` through every mediated loading path. + +An additional module ID reported by `module.builtinModules`, a new top-level export, an unexpected descriptor kind, or a change to reviewed direct nested objects and exported constructor/prototype surfaces causes worker startup to fail before guest source is compiled or imported. A recognized but unclassified identity that is not reported by that inventory is denied when requested by the resolver, `_load()`, or `process.getBuiltinModule()` guards. + +This policy governs Node built-ins. It does not create a new ECMAScript lexical global scope; explicit global-scope control remains a separate design question. + +## Why this design + +Four approaches were considered. + +### Per-API denylist only + +The earlier implementation preloaded and disabled known dangerous exports. It preserved compatibility, but a newly shipped module or export was available until reviewed. Node 26.8 added new ZIP APIs and Node 26.9 added `node:ffi`, demonstrating the problem. + +This remains useful as the attenuation layer, but it is not sufficient as the upgrade boundary. + +### CommonJS interception only + +Replacing `Module._load()`, hiding wrapper globals, or controlling `createRequire()` cannot mediate native ESM imports or `process.getBuiltinModule()`. Those controls remain defense in depth, not the primary policy boundary. + +### Asynchronous custom loader or separate compartment + +`module.register()` executes asynchronous hooks in a separate internal worker. That would introduce another realm whose permissions, intrinsics, protocol, lifetime, and failure behavior would require a separate security analysis. A SES or compartment module system would also change native ESM and staged-package compatibility substantially. Those approaches were not adopted here. + +### Reviewed manifest plus a trusted synchronous hook + +The selected design combines: + +1. an exact built-in identity profile for the supported Node 26 runtime ranges; +2. descriptor-only manifests for pre-hardening CommonJS exports, post-hardening ESM namespaces, direct object-valued exports, exported functions, and constructor prototype chains; +3. the existing module-specific attenuation; +4. a trusted synchronous `module.registerHooks()` resolve hook installed after permission drop and hardening, but before guest compilation or import; +5. independent immutable policy checks in `Module._load()` and `process.getBuiltinModule()`; and +6. a CI gate across the floor, the Node 26.8 API boundary, current 26.x, and Linux, macOS, and Windows. + +The JavaScript policy can only remove or attenuate visible capabilities; it cannot restore a permission omitted from the worker or dropped by `process.permission.drop()`. Synchronous hooks run in the sandbox worker realm and close over primitives captured before guest execution. Guest-facing `module.register()`, `module.registerHooks()`, resolver mutation, and compile-cache APIs remain disabled. The returned hook registration is retained privately for the worker lifetime. + +## Loading paths + +The same disposition is enforced for the applicable forms below. + +| Loading path | Enforcement | +| --- | --- | +| Static and dynamic native ESM, including staged modules | Trusted synchronous resolve hook | +| Bare and `node:` built-in spellings | Exact raw-ID policy plus canonical alias lookup | +| ESM named exports and namespace default exports | Pre-guest namespace-name check, attenuation, and `syncBuiltinESMExports()` | +| CommonJS `require()` and `module.createRequire()` | Resolve hook and immutable `_load()` wrapper | +| `Module._load()`, `Module.Module._load()`, and ESM default aliases | Immutable `_load()` wrapper using the same policy | +| `process.getBuiltinModule()` and imported `node:process` aliases | Immutable wrapper using the same policy | +| `vm.Script` and `vm.compileFunction` with the main-context default loader | Native loader reaches the synchronous resolve hook | +| Guest loader registration and compile-cache mutation | Denied | + +The manifest preserves the raw spellings returned by `module.builtinModules`. This matters because prefix-only IDs such as `node:ffi` are not equivalent to packages named `ffi`. + +## Reviewed inventory + +The following groups summarize the machine-readable policy. The source file is authoritative and is checked for sorting, duplicates, missing classifications, and profile drift. + +### Allowed computation libraries + +- assertions: `assert`, `assert/strict` +- binary and text utilities: `buffer`, `string_decoder`, `util`, `util/types` +- events and streams: `domain`, `events`, `stream`, `stream/consumers`, `stream/promises`, `stream/web` +- paths and URLs: `path`, `path/posix`, `path/win32`, `url` +- data/compatibility utilities: `constants`, `punycode`, `querystring` +- local scheduling and parsing: `timers`, `timers/promises`, `readline`, `readline/promises` +- code evaluation without additional host authority: `vm` +- the deprecated `sys` alias, whose reviewed surface is the `util` compatibility API + +`zlib` is classified as attenuated in the machine policy because Node 26.8 added file-oriented ZIP APIs. In-memory compression remains available; ZIP constructors and file/archive operations are immutable denial stubs. + +### Attenuated modules + +- `async_hooks`, `child_process` +- `crypto` +- `dgram`, `dns`, `dns/promises`, `http`, `http2`, `https`, `net`, `tls` +- `inspector`, `inspector/promises` +- `module`, `process`, `worker_threads` +- `node:sea`, `node:sqlite`, `v8`, `wasi` +- `os`, `perf_hooks`, `tty` +- `zlib` + +Attenuation is module-specific. It includes complete callable denial for WASI, SQLite, OS, and async hooks; callable V8 denial except for the documented compatibility probe; network and child-process denial; process identity/resource virtualization; immutable loader restrictions; staged-root filesystem behavior; virtual worker-relative timing; and the documented retained compatibility probe `v8.startupSnapshot.isBuildingSnapshot()`. + +`crypto.createMac()` and `crypto.getMacs()` added in Node 26.9 were reviewed as cryptographic algorithm APIs, not network-interface access. They remain available. OpenSSL engine selection, FIPS mutation, and secure-heap telemetry remain denied. + +### Mode-dependent filesystem modules + +- `fs` +- `fs/promises` + +Source-string workers cannot load either module. Local-file workers may load them, but only the synchronous path readers required by Node's native module loader remain callable, and reads are confined to the private staged snapshot. Descriptor-based access remains owner-accounted and bounded. + +### Module-level denial + +- internal network aliases: `_http_agent`, `_http_client`, `_http_common`, `_http_incoming`, `_http_outgoing`, `_http_server`, `_tls_common`, `_tls_wrap` +- `cluster` +- the `console` module (the separately virtualized global console remains available) +- `diagnostics_channel` +- `node:ffi` +- `node:test`, `node:test/reporters` +- `repl` +- `trace_events` + +`node:quic` is an explicitly denied optional identity. The worker does not enable host experimental flags, and an available optional identity never becomes guest-accessible merely because a future supported runtime recognizes it. + +## Startup order and failure behavior + +For every worker: + +1. trusted built-ins and descriptor operations are captured; +2. the policy embedded by the package is validated and recursively frozen; +3. the worker permission is irreversibly dropped; +4. the runtime built-in ID profile and CommonJS export descriptors are checked; +5. authority-bearing exports are attenuated and ESM bindings synchronized; +6. ESM namespace names are checked; +7. the trusted synchronous resolve hook is installed and all guest mutation routes are disabled; and +8. only then is guest source compiled or imported. + +The checks inspect own property descriptors and never invoke export accessors. CommonJS entries record top-level names and descriptor categories before attenuation; ESM entries record names and categories after attenuation. A bounded graph additionally records direct object-valued exports, exported function surfaces, and constructor prototype chains, with fixed node, property, and prototype-depth budgets. Platform-specific numeric members of `constants` and direct `.constants` objects are omitted by name because they are inert values that differ across operating systems; an accessor, object, function, symbol, or other non-numeric addition still fails closed. The lazy `process.allowedNodeEnvironmentFlags` object is the only reviewed optional graph path because Node may materialize its accessor at different bootstrap points. + +A mismatch rejects startup with a bounded error, terminates the worker through the normal lifecycle, retains admission until actual exit, and does not execute guest source. + +## Runtime upgrade procedure + +Run `npm run test:node-capabilities` with Node 26.5.1, Node 26.8.1 (the ZIP API boundary), and the current Node 26.x release. CI runs it in all nine operating-system/runtime matrix jobs. + +To produce deterministic review input without changing the approved manifest, run the following on Linux, macOS, and Windows under each of those three Node versions: + +```sh +npm run generate:node-capability-candidate > capability-candidate.json +``` + +The candidate records the runtime identity inventory, pre-hardening CommonJS descriptors, post-hardening ESM descriptors, and nested/prototype graph. The tool uses a temporary source copy with only the three manifest comparisons disabled; permission dropping, attenuation, and resolver hardening remain in production order. It deletes the copy afterward and never edits `src/node-capability-surfaces.js`. Candidate JSON is untrusted review input, not an approval artifact. + +When the checker fails: + +1. Do not accept either the manifest or generated candidate automatically. +2. Read the Node release notes and implementation for every added, removed, or changed identity, top-level descriptor, nested object, function, or prototype entry. +3. Determine whether the Permission Model covers the operation and whether it has same-process effects. +4. Assign a disposition and rationale. +5. Add denial or attenuation before updating the manifest. +6. Test every applicable alias, ESM named/default form, mutation attempt, and repeated `syncBuiltinESMExports()` behavior. +7. Update the identity profile, surface manifest, this document, and compatibility notes in the same reviewed change. +8. Run the full floor/API-boundary/current, Linux/macOS/Windows matrix before changing the supported-runtime claim. + +The checker prints the runtime, platform, architecture, and exact identity and top-level export/name diffs, then starts a real sandbox so the embedded runtime verifier independently checks post-attenuation ESM categories and nested/prototype graph drift. Candidate generation is intentionally separate from verification and only writes JSON to standard output, so CI cannot auto-approve a new capability. + +## Compatibility and cost + +The intended compatibility changes are: + +- unapproved built-ins now fail resolution with `ERR_ACCESS_DENIED` instead of becoming available by default; +- a Node 26 update with an unreviewed identity or export change fails worker startup until the package policy is reviewed; +- denied module identities may no longer return an importable namespace of denial stubs; +- ordinary packages whose names resemble prefix-only built-ins remain ordinary package specifiers; +- the inherited `%TypedArray%.prototype.length` descriptor is made non-configurable before guest execution because Node's synchronous resolver hook uses async-context internals that read it. Code that replaces this shared intrinsic descriptor is incompatible. + +A single Linux x64 sequential eight-worker benchmark used `npm run measure:workers -- 8` with explicit full-command `PATH` selection and forced GC between samples. The median excludes the first cold worker. Compared with `main` commit `2c49f6e`, which includes the same Heapjack hardening, the final policy changed: + +| Runtime | Before | With policy | Startup increase | Approx. active RSS increase per worker | +| --- | ---: | ---: | ---: | ---: | +| Node 26.5.1, Linux x64 | 143.01 ms | 233.68 ms | 90.67 ms (63%) | 8.37 MiB | +| Node 26.9.0, Linux x64 | 107.74 ms | 189.43 ms | 81.69 ms (76%) | 10.09 MiB | + +The full identity, export, and graph scan runs once per worker. Ordinary requests without new module resolution do not repeat it; later dynamic module resolution still performs the constant-time policy lookup in the trusted hook. Worker pooling was not introduced because the project does not have a safe realm-reset invariant. Deployments should account for the additional startup cost or use longer-lived sessions. + +## Residual risks and boundaries + +- The policy covers documented built-in IDs plus the explicitly listed internal aliases; undocumented native internals cannot be exhaustively enumerated. +- Descriptor checks do not prove that the semantics of an existing native function are unchanged. Objects reachable only by invoking native accessors are not traversed because policy verification never executes accessors. Release notes, source review, exploit regressions, the Permission Model, and an outer OS sandbox remain necessary. +- Module policy does not control every global lexical binding. That distinct problem is tracked by [issue #5, “Evaluate explicit global scope capabilities instead of individual global removal”](https://github.com/platformatic/secure-eval-worker/issues/5). +- Native/runtime vulnerabilities, shared-process denial of service, and mutable same-UID filesystem namespaces remain outside the worker-only boundary. +- Worker isolation and the Permission Model remain defense in depth, not an OS security boundary. diff --git a/package.json b/package.json index f54a9e8..92dbaf4 100644 --- a/package.json +++ b/package.json @@ -22,6 +22,8 @@ "scripts": { "test": "node --test", "test:coverage": "node --test --experimental-test-coverage", + "test:node-capabilities": "node --no-warnings scripts/check-node-capabilities.js", + "generate:node-capability-candidate": "node --no-warnings scripts/generate-node-capability-candidate.js", "test:types": "node scripts/check-package-types.js", "test:package": "node scripts/check-package-contents.js", "measure:workers": "node --expose-gc scripts/measure-worker-overhead.js" diff --git a/scripts/check-node-capabilities.js b/scripts/check-node-capabilities.js new file mode 100644 index 0000000..83fe9d3 --- /dev/null +++ b/scripts/check-node-capabilities.js @@ -0,0 +1,215 @@ +import assert from 'node:assert/strict' +import { builtinModules } from 'node:module' +import { Worker } from 'node:worker_threads' + +import { runUntrustedCode } from '../src/index.js' +import { + diffExactLists, + diffSurfaceSignatures +} from './node-capability-signatures.js' +import { + NODE_BUILTIN_POLICY, + NODE_BUILTIN_PROFILES +} from '../src/node-capability-policy.js' +import { + NODE_BUILTIN_SURFACE_BASE, + NODE_BUILTIN_SURFACE_FROM_26_8, + NODE_BUILTIN_SURFACE_FROM_26_9, + NODE_BUILTIN_SURFACE_PLATFORM +} from '../src/node-capability-surfaces.js' + +const dispositions = ['allowed', 'attenuated', 'modeDependent', 'denied'] +const classified = new Map() + +for (const disposition of dispositions) { + const ids = NODE_BUILTIN_POLICY[disposition] + assert.deepEqual(ids, [...ids].sort(), `${disposition} policy entries must be sorted`) + for (const id of ids) { + assert.equal(classified.has(id), false, `${id} has multiple capability dispositions`) + classified.set(id, disposition) + } +} + +for (const [profileName, profile] of Object.entries(NODE_BUILTIN_PROFILES)) { + assert.deepEqual(profile, [...profile].sort(), `${profileName} profile must be sorted`) + for (const id of profile) { + assert.ok(classified.has(id), `${profileName} contains unclassified builtin ${id}`) + } +} + +for (const id of classified.keys()) { + const inProfile = Object.values(NODE_BUILTIN_PROFILES).some(profile => profile.includes(id)) + assert.ok(inProfile, `classified builtin ${id} is absent from every runtime profile`) +} + +const [, minor] = process.versions.node.split('.').map(Number) +const profileName = minor >= 9 ? 'from26_9' : 'before26_9' +const expectedModules = NODE_BUILTIN_PROFILES[profileName] +const actualModules = [...builtinModules].sort() +reportDifference('builtin module IDs', expectedModules, actualModules) + +const surfacedIds = [ + ...NODE_BUILTIN_POLICY.allowed, + ...NODE_BUILTIN_POLICY.attenuated, + ...NODE_BUILTIN_POLICY.modeDependent +].sort() +assert.deepEqual( + Object.keys(NODE_BUILTIN_SURFACE_BASE).sort(), + surfacedIds, + 'surface manifest must cover every guest-reachable builtin' +) +for (const additions of [NODE_BUILTIN_SURFACE_FROM_26_8, NODE_BUILTIN_SURFACE_FROM_26_9]) { + for (const id of Object.keys(additions)) { + assert.ok(Object.hasOwn(NODE_BUILTIN_SURFACE_BASE, id), `surface addition has unknown builtin ${id}`) + } +} +for (const [platform, overrides] of Object.entries(NODE_BUILTIN_SURFACE_PLATFORM)) { + for (const id of Object.keys(overrides)) { + assert.ok( + Object.hasOwn(NODE_BUILTIN_SURFACE_BASE, id), + `${platform} surface override has unknown builtin ${id}` + ) + } +} + +const platformSurfaces = NODE_BUILTIN_SURFACE_PLATFORM[process.platform] +assert.ok(platformSurfaces, `unsupported capability platform ${process.platform}`) +const observedSurfaces = await inspectWorkerSurfaces(surfacedIds) +for (const id of surfacedIds) { + const base = platformSurfaces[id] ?? NODE_BUILTIN_SURFACE_BASE[id] + const additions26_8 = minor >= 8 ? NODE_BUILTIN_SURFACE_FROM_26_8[id] : undefined + const additions26_9 = minor >= 9 ? NODE_BUILTIN_SURFACE_FROM_26_9[id] : undefined + reportSurfaceDifference( + `${id} CommonJS exports`, + [...base[0], ...(additions26_8?.[0] ?? []), ...(additions26_9?.[0] ?? [])].sort(), + observedSurfaces[id][0], + false + ) + reportSurfaceDifference( + `${id} ESM namespace exports`, + [...base[1], ...(additions26_8?.[1] ?? []), ...(additions26_9?.[1] ?? [])].sort(), + observedSurfaces[id][1], + true + ) +} + +// The worker performs descriptor-only checks against the committed CommonJS +// and ESM surface manifest before compiling or importing this source. Keeping +// this probe in the explicit gate prevents CI from relying only on unrelated +// test coverage to exercise the runtime check. +assert.equal(await runUntrustedCode('return true'), true) + +console.log(`Node capability policy matches ${process.version} on ${process.platform}/${process.arch}`) + +async function inspectWorkerSurfaces (ids) { + const source = String.raw` + 'use strict' + for (const id of [ + 'node:crypto', 'node:async_hooks', 'node:child_process', 'node:events', + 'node:fs', 'node:fs/promises', 'node:dgram', 'node:dns', + 'node:dns/promises', 'node:http', 'node:http2', 'node:https', + 'node:module', 'node:net', 'node:os', 'node:perf_hooks', 'node:process', + 'node:sea', 'node:sqlite', 'node:tls', 'node:tty', 'node:v8', + 'node:wasi', 'node:zlib', 'node:util/types', 'node:worker_threads', + 'node:ffi', 'node:trace_events', 'node:quic' + ]) { + try { require(id) } catch {} + } + for (const id of [ + '_http_agent', '_http_client', '_http_common', '_http_incoming', + '_http_outgoing', '_http_server', '_tls_common', '_tls_wrap' + ]) require(id) + + const codes = { + bigint: 'i', boolean: 'b', function: 'f', number: 'n', object: 'o', + string: 's', symbol: 'y', undefined: 'u' + } + const signature = (value, omitNumericConstants) => { + const descriptors = Object.getOwnPropertyDescriptors(value) + const result = [] + for (const key of Reflect.ownKeys(descriptors)) { + const descriptor = descriptors[key] + if (omitNumericConstants && Object.hasOwn(descriptor, 'value') && + typeof descriptor.value === 'number') continue + const name = typeof key === 'symbol' + ? '@@' + (Symbol.keyFor(key) ?? key.description ?? '') + : key + const kind = Object.hasOwn(descriptor, 'value') + ? (descriptor.value === null ? 'l' : codes[typeof descriptor.value]) + : 'a' + result.push(name + ':' + kind) + } + return result.sort() + } + + ;(async () => { + const { parentPort, workerData } = require('node:worker_threads') + const result = {} + for (const id of workerData) { + const specifier = id.startsWith('node:') ? id : 'node:' + id + const omitNumericConstants = id === 'constants' + result[id] = [ + signature(require(specifier), omitNumericConstants), + signature(await import(specifier), omitNumericConstants) + ] + } + parentPort.postMessage(result) + })().catch(error => { throw error }) + ` + return new Promise((resolve, reject) => { + const worker = new Worker(source, { + env: {}, + eval: true, + execArgv: [ + '--permission', + '--allow-worker', + '--disable-warning=PERM0006', + '--disable-warning=DEP0192', + '--disable-warning=ExperimentalWarning' + ], + stderr: true, + stdout: true, + workerData: ids + }) + worker.once('message', resolve) + worker.once('error', reject) + worker.once('exit', code => { + if (code !== 0) reject(new Error(`capability inspection worker exited with code ${code}`)) + }) + }) +} + +function reportSurfaceDifference (label, expected, actual, namesOnly) { + const { added, removed } = diffSurfaceSignatures(expected, actual, { namesOnly }) + + if (!namesOnly && label === 'process CommonJS exports') { + const lazyIndex = removed.findIndex(value => value === 'allowedNodeEnvironmentFlags:a|o') + const actualLazy = added.findIndex(value => value === 'allowedNodeEnvironmentFlags:a' || + value === 'allowedNodeEnvironmentFlags:o') + if (lazyIndex !== -1 && actualLazy !== -1) { + removed.splice(lazyIndex, 1) + added.splice(actualLazy, 1) + } + } + reportChanges(label, added, removed) +} + +function reportDifference (label, expected, actual) { + const { added, removed } = diffExactLists(expected, actual) + reportChanges(label, added, removed) +} + +function reportChanges (label, added, removed) { + if (added.length === 0 && removed.length === 0) return + + const details = [ + `Unreviewed Node capability surface change: ${label}`, + `runtime: ${process.version} ${process.platform}/${process.arch}` + ] + if (added.length > 0) details.push(`added: ${JSON.stringify(added)}`) + if (removed.length > 0) details.push(`removed: ${JSON.stringify(removed)}`) + details.push( + 'Review Node release notes and source, classify the change, add hardening and regressions where needed, then update the policy in the same reviewed change.' + ) + throw new Error(details.join('\n')) +} diff --git a/scripts/check-package-contents.js b/scripts/check-package-contents.js index 3745cbd..3fec8b6 100644 --- a/scripts/check-package-contents.js +++ b/scripts/check-package-contents.js @@ -23,6 +23,7 @@ try { 'docs/deferred-capabilities.md', 'docs/error-values.md', 'docs/module-dependencies.md', + 'docs/node-capability-policy.md', 'docs/one-shot-pooling.md', 'docs/vercel-labs-run-comparison.md', 'docs/worker-admission.md', @@ -33,6 +34,8 @@ try { 'src/index.js', 'src/internal.js', 'src/local-files.js', + 'src/node-capability-policy.js', + 'src/node-capability-surfaces.js', 'src/session-bootstrap.js', 'src/session.js' ] diff --git a/scripts/generate-node-capability-candidate.js b/scripts/generate-node-capability-candidate.js new file mode 100644 index 0000000..0626c9d --- /dev/null +++ b/scripts/generate-node-capability-candidate.js @@ -0,0 +1,234 @@ +import { builtinModules } from 'node:module' +import { + cpSync, + mkdtempSync, + readFileSync, + rmSync, + writeFileSync +} from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { pathToFileURL } from 'node:url' +import { Worker } from 'node:worker_threads' + +import { NODE_BUILTIN_POLICY } from '../src/node-capability-policy.js' + +// This tool deliberately generates review input; it never rewrites the +// approved manifest. It runs a temporary source copy whose three manifest +// comparisons are disabled while retaining the production hardening order. +const root = mkdtempSync(join(tmpdir(), 'secure-eval-worker-capability-candidate-')) +const sourceRoot = new URL('../src/', import.meta.url) +const copiedSource = join(root, 'src') +const ids = [ + ...NODE_BUILTIN_POLICY.allowed, + ...NODE_BUILTIN_POLICY.attenuated, + ...NODE_BUILTIN_POLICY.modeDependent +].sort() + +try { + cpSync(sourceRoot, copiedSource, { recursive: true }) + writeFileSync(join(root, 'package.json'), '{"type":"module"}\n') + const bootstrapPath = join(copiedSource, 'session-bootstrap.js') + let bootstrapSource = readFileSync(bootstrapPath, 'utf8').replace(/\r\n?/g, '\n') + bootstrapSource = replaceExactly( + bootstrapSource, + ' await verifyNodeCapabilityPolicy()\n', + ` // Candidate generation: preload reviewed built-ins but intentionally skip comparisons.\n` + + ` for (const candidateId of preparedNodeCapabilityPolicy.surfacedIds) {\n` + + ` const candidateSpecifier = candidateId.startsWith('node:')\n` + + ` ? candidateId\n` + + ` : 'node:' + candidateId\n` + + ` reflectApply(moduleLoad, moduleBuiltin, [candidateSpecifier])\n` + + ` }\n` + ) + bootstrapSource = replaceExactly( + bootstrapSource, + ' await verifyNodeCapabilityNamespaces()\n verifyNodeCapabilityGraphs()\n', + ' // Candidate generation: post-hardening namespace/graph verification is intentionally skipped.\n' + ) + writeFileSync(bootstrapPath, bootstrapSource) + + const commonjs = await inspectPreHardeningCommonJs(ids) + const entry = join(root, 'entry.mjs') + writeFileSync(entry, candidateGuestSource(ids)) + const { runUntrustedFile } = await import( + pathToFileURL(join(copiedSource, 'index.js')).href + ) + const postHardening = await runUntrustedFile(entry, { + rootDirectory: root, + timeoutMs: 60_000, + maxMessageBytes: 32 * 1024 * 1024, + maxOutputBytes: 64 * 1024 * 1024 + }) + + process.stdout.write(JSON.stringify({ + node: process.version, + platform: process.platform, + arch: process.arch, + builtinModules: [...builtinModules].sort(), + commonjs, + esm: postHardening.esm, + graph: postHardening.graph + }, null, 2) + '\n') +} finally { + rmSync(root, { force: true, recursive: true }) +} + +function replaceExactly (source, oldText, newText) { + const first = source.indexOf(oldText) + if (first < 0 || source.indexOf(oldText, first + oldText.length) >= 0) { + throw new Error(`candidate source marker must occur exactly once: ${JSON.stringify(oldText)}`) + } + return source.slice(0, first) + newText + source.slice(first + oldText.length) +} + +function inspectPreHardeningCommonJs (moduleIds) { + const workerSource = String.raw` + 'use strict' + const codes = { + bigint: 'i', boolean: 'b', function: 'f', number: 'n', object: 'o', + string: 's', symbol: 'y', undefined: 'u' + } + const signature = (value, omitNumericConstants) => { + const descriptors = Object.getOwnPropertyDescriptors(value) + const result = [] + for (const key of Reflect.ownKeys(descriptors)) { + const descriptor = descriptors[key] + if (omitNumericConstants && Object.hasOwn(descriptor, 'value') && + typeof descriptor.value === 'number') continue + const name = typeof key === 'symbol' + ? '@@' + (Symbol.keyFor(key) ?? key.description ?? '') + : key + const kind = Object.hasOwn(descriptor, 'value') + ? (descriptor.value === null ? 'l' : codes[typeof descriptor.value]) + : 'a' + result.push(name + ':' + kind) + } + return result.sort() + } + for (const id of [ + 'node:crypto', 'node:async_hooks', 'node:child_process', 'node:events', + 'node:fs', 'node:fs/promises', 'node:dgram', 'node:dns', + 'node:dns/promises', 'node:http', 'node:http2', 'node:https', + 'node:module', 'node:net', 'node:os', 'node:perf_hooks', 'node:process', + 'node:sea', 'node:sqlite', 'node:tls', 'node:tty', 'node:v8', + 'node:wasi', 'node:zlib', 'node:util/types', 'node:worker_threads', + 'node:ffi', 'node:trace_events', 'node:quic' + ]) { + try { require(id) } catch {} + } + for (const id of [ + '_http_agent', '_http_client', '_http_common', '_http_incoming', + '_http_outgoing', '_http_server', '_tls_common', '_tls_wrap' + ]) require(id) + + const { parentPort, workerData } = require('node:worker_threads') + const result = {} + for (const id of workerData) { + const specifier = id.startsWith('node:') ? id : 'node:' + id + result[id] = signature(require(specifier), id === 'constants') + } + parentPort.postMessage(result) + ` + return new Promise((resolve, reject) => { + const worker = new Worker(workerSource, { + env: {}, + eval: true, + execArgv: [ + '--permission', + '--allow-worker', + '--disable-warning=PERM0006', + '--disable-warning=DEP0192', + '--disable-warning=ExperimentalWarning' + ], + stderr: true, + stdin: false, + stdout: false, + workerData: moduleIds + }) + worker.once('message', resolve) + worker.once('error', reject) + }) +} + +function candidateGuestSource (moduleIds) { + return ` +export default async () => { +const ids = ${JSON.stringify(moduleIds)} +const codes = { + bigint: 'i', boolean: 'b', function: 'f', number: 'n', object: 'o', + string: 's', symbol: 'y', undefined: 'u' +} +const keyName = key => typeof key === 'symbol' + ? '@@' + (Symbol.keyFor(key) ?? key.description ?? '') + : key +const signature = (value, omitNumericConstants = false) => { + const descriptors = Object.getOwnPropertyDescriptors(value) + const result = [] + for (const key of Reflect.ownKeys(descriptors)) { + const descriptor = descriptors[key] + if (omitNumericConstants && Object.hasOwn(descriptor, 'value') && + typeof descriptor.value === 'number') continue + const kind = Object.hasOwn(descriptor, 'value') + ? (descriptor.value === null ? 'l' : codes[typeof descriptor.value]) + : 'a' + result.push(keyName(key) + ':' + kind) + } + return result.sort() +} +const stops = new Set([ + Object.prototype, Function.prototype, Array.prototype, Map.prototype, + Set.prototype, WeakMap.prototype, WeakSet.prototype, Promise.prototype, + Date.prototype, RegExp.prototype, Error.prototype, ArrayBuffer.prototype, + DataView.prototype, Int8Array.prototype, Uint8Array.prototype, + Uint8ClampedArray.prototype, Int16Array.prototype, Uint16Array.prototype, + Int32Array.prototype, Uint32Array.prototype, Float32Array.prototype, + Float64Array.prototype, BigInt64Array.prototype, BigUint64Array.prototype +]) +const excludedObject = value => Array.isArray(value) || ArrayBuffer.isView(value) || + value instanceof Map || value instanceof Set || value instanceof WeakMap || + value instanceof WeakSet || value instanceof Date || value instanceof RegExp || + value instanceof ArrayBuffer || value instanceof SharedArrayBuffer +const inspectObject = (value, path, graph) => { + if (path === 'process.env' || value === null || typeof value !== 'object' || + excludedObject(value)) return + graph[path] = signature(value, path.endsWith('.constants')) + let prototype = Object.getPrototypeOf(value) + for (let level = 0; prototype && !stops.has(prototype) && level < 12; level++) { + graph[path + '[[Prototype]]' + level] = signature(prototype) + prototype = Object.getPrototypeOf(prototype) + } +} +const inspectFunction = (value, path, graph) => { + if (typeof value !== 'function') return + graph[path + '[[Function]]'] = signature(value) + const descriptor = Object.getOwnPropertyDescriptor(value, 'prototype') + if (descriptor && Object.hasOwn(descriptor, 'value')) { + inspectObject(descriptor.value, path + '.prototype', graph) + } +} +const esm = {} +const graph = {} +for (const id of ids) { + const specifier = id.startsWith('node:') ? id : 'node:' + id + const namespace = await import(specifier) + esm[id] = signature(namespace, id === 'constants') + const rootValue = namespace.default ?? namespace + const moduleGraph = {} + const descriptors = Object.getOwnPropertyDescriptors(rootValue) + for (const key of Reflect.ownKeys(descriptors)) { + const descriptor = descriptors[key] + if (!Object.hasOwn(descriptor, 'value') || descriptor.value === null) continue + const path = id + '.' + keyName(key) + if (typeof descriptor.value === 'object') { + inspectObject(descriptor.value, path, moduleGraph) + } else if (typeof descriptor.value === 'function') { + inspectFunction(descriptor.value, path, moduleGraph) + } + } + graph[id] = moduleGraph +} +return { esm, graph } +} +` +} diff --git a/scripts/node-capability-signatures.js b/scripts/node-capability-signatures.js new file mode 100644 index 0000000..94a1b63 --- /dev/null +++ b/scripts/node-capability-signatures.js @@ -0,0 +1,48 @@ +export function descriptorSignature (value) { + const descriptors = Object.getOwnPropertyDescriptors(value) + return Reflect.ownKeys(descriptors).map(key => { + const descriptor = descriptors[key] + const name = typeof key === 'symbol' + ? `@@${Symbol.keyFor(key) ?? key.description ?? ''}` + : key + let kind + if (!Object.hasOwn(descriptor, 'value')) kind = 'a' + else if (descriptor.value === null) kind = 'l' + else { + kind = { + bigint: 'i', + boolean: 'b', + function: 'f', + number: 'n', + object: 'o', + string: 's', + symbol: 'y', + undefined: 'u' + }[typeof descriptor.value] + } + return `${name}:${kind}` + }).sort() +} + +export function diffExactLists (expected, actual) { + const expectedSet = new Set(expected) + const actualSet = new Set(actual) + return { + added: actual.filter(value => !expectedSet.has(value)), + removed: expected.filter(value => !actualSet.has(value)) + } +} + +export function diffSurfaceSignatures (expected, actual, { namesOnly = false } = {}) { + const normalize = signature => namesOnly + ? signature.slice(0, signature.lastIndexOf(':')) + : signature + const expectedNames = expected.map(normalize) + const actualNames = actual.map(normalize) + const expectedSet = new Set(expectedNames) + const actualSet = new Set(actualNames) + return { + added: actual.filter((value, index) => !expectedSet.has(actualNames[index])), + removed: expected.filter((value, index) => !actualSet.has(expectedNames[index])) + } +} diff --git a/src/node-capability-policy.js b/src/node-capability-policy.js new file mode 100644 index 0000000..67531d1 --- /dev/null +++ b/src/node-capability-policy.js @@ -0,0 +1,223 @@ +// This policy is consumed by both the worker bootstrap and the runtime-upgrade +// check. Keep raw builtinModules spellings: prefix-only modules such as +// node:ffi must not be conflated with package specifiers. +export const NODE_BUILTIN_POLICY = Object.freeze({ + allowed: Object.freeze([ + 'assert', + 'assert/strict', + 'buffer', + 'constants', + 'domain', + 'events', + 'path', + 'path/posix', + 'path/win32', + 'punycode', + 'querystring', + 'readline', + 'readline/promises', + 'stream', + 'stream/consumers', + 'stream/promises', + 'stream/web', + 'string_decoder', + 'sys', + 'timers', + 'timers/promises', + 'url', + 'util', + 'util/types', + 'vm' + ]), + attenuated: Object.freeze([ + 'async_hooks', + 'child_process', + 'crypto', + 'dgram', + 'dns', + 'dns/promises', + 'http', + 'http2', + 'https', + 'inspector', + 'inspector/promises', + 'module', + 'net', + 'node:sea', + 'node:sqlite', + 'os', + 'perf_hooks', + 'process', + 'tls', + 'tty', + 'v8', + 'wasi', + 'worker_threads', + 'zlib' + ]), + modeDependent: Object.freeze([ + 'fs', + 'fs/promises' + ]), + denied: Object.freeze([ + '_http_agent', + '_http_client', + '_http_common', + '_http_incoming', + '_http_outgoing', + '_http_server', + '_tls_common', + '_tls_wrap', + 'cluster', + 'console', + 'diagnostics_channel', + 'node:ffi', + 'node:test', + 'node:test/reporters', + 'repl', + 'trace_events' + ]), + optionalDenied: Object.freeze([ + 'node:quic' + ]) +}) + +export const NODE_BUILTIN_PROFILES = Object.freeze({ + before26_9: Object.freeze([ + '_http_agent', + '_http_client', + '_http_common', + '_http_incoming', + '_http_outgoing', + '_http_server', + '_tls_common', + '_tls_wrap', + 'assert', + 'assert/strict', + 'async_hooks', + 'buffer', + 'child_process', + 'cluster', + 'console', + 'constants', + 'crypto', + 'dgram', + 'diagnostics_channel', + 'dns', + 'dns/promises', + 'domain', + 'events', + 'fs', + 'fs/promises', + 'http', + 'http2', + 'https', + 'inspector', + 'inspector/promises', + 'module', + 'net', + 'node:sea', + 'node:sqlite', + 'node:test', + 'node:test/reporters', + 'os', + 'path', + 'path/posix', + 'path/win32', + 'perf_hooks', + 'process', + 'punycode', + 'querystring', + 'readline', + 'readline/promises', + 'repl', + 'stream', + 'stream/consumers', + 'stream/promises', + 'stream/web', + 'string_decoder', + 'sys', + 'timers', + 'timers/promises', + 'tls', + 'trace_events', + 'tty', + 'url', + 'util', + 'util/types', + 'v8', + 'vm', + 'wasi', + 'worker_threads', + 'zlib' + ]), + from26_9: Object.freeze([ + '_http_agent', + '_http_client', + '_http_common', + '_http_incoming', + '_http_outgoing', + '_http_server', + '_tls_common', + '_tls_wrap', + 'assert', + 'assert/strict', + 'async_hooks', + 'buffer', + 'child_process', + 'cluster', + 'console', + 'constants', + 'crypto', + 'dgram', + 'diagnostics_channel', + 'dns', + 'dns/promises', + 'domain', + 'events', + 'fs', + 'fs/promises', + 'http', + 'http2', + 'https', + 'inspector', + 'inspector/promises', + 'module', + 'net', + 'node:ffi', + 'node:sea', + 'node:sqlite', + 'node:test', + 'node:test/reporters', + 'os', + 'path', + 'path/posix', + 'path/win32', + 'perf_hooks', + 'process', + 'punycode', + 'querystring', + 'readline', + 'readline/promises', + 'repl', + 'stream', + 'stream/consumers', + 'stream/promises', + 'stream/web', + 'string_decoder', + 'sys', + 'timers', + 'timers/promises', + 'tls', + 'trace_events', + 'tty', + 'url', + 'util', + 'util/types', + 'v8', + 'vm', + 'wasi', + 'worker_threads', + 'zlib' + ]) +}) diff --git a/src/node-capability-surfaces.js b/src/node-capability-surfaces.js new file mode 100644 index 0000000..15e5011 --- /dev/null +++ b/src/node-capability-surfaces.js @@ -0,0 +1,19 @@ +// Reviewed descriptor-kind manifests for guest-reachable Node built-ins. +export const NODE_BUILTIN_SURFACE_BASE = Object.freeze({"assert":[["Assert:f","AssertionError:f","deepEqual:f","deepStrictEqual:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","length:n","match:f","name:s","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","prototype:o","rejects:f","strict:f","strictEqual:f","throws:f"],["@@Symbol.toStringTag:s","Assert:f","AssertionError:f","deepEqual:f","deepStrictEqual:f","default:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","match:f","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","rejects:f","strict:f","strictEqual:f","throws:f"]],"assert/strict":[["Assert:f","AssertionError:f","deepEqual:f","deepStrictEqual:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","length:n","match:f","name:s","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","prototype:o","rejects:f","strict:f","strictEqual:f","throws:f"],["@@Symbol.toStringTag:s","Assert:f","AssertionError:f","deepEqual:f","deepStrictEqual:f","default:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","match:f","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","rejects:f","strict:f","strictEqual:f","throws:f"]],"async_hooks":[["AsyncLocalStorage:a","AsyncResource:f","asyncWrapProviders:o","createHook:f","executionAsyncId:f","executionAsyncResource:f","triggerAsyncId:f"],["@@Symbol.toStringTag:s","AsyncLocalStorage:f","AsyncResource:f","asyncWrapProviders:o","createHook:f","default:o","executionAsyncId:f","executionAsyncResource:f","triggerAsyncId:f"]],"buffer":[["Blob:f","Buffer:f","File:f","INSPECT_MAX_BYTES:a","atob:f","btoa:f","constants:o","isAscii:f","isUtf8:f","kMaxLength:n","kStringMaxLength:n","resolveObjectURL:f","transcode:f"],["@@Symbol.toStringTag:s","Blob:f","Buffer:f","File:f","INSPECT_MAX_BYTES:n","atob:f","btoa:f","constants:o","default:o","isAscii:f","isUtf8:f","kMaxLength:n","kStringMaxLength:n","resolveObjectURL:f","transcode:f"]],"child_process":[["ChildProcess:f","_forkChild:f","exec:f","execFile:f","execFileSync:f","execSync:f","fork:f","spawn:f","spawnSync:f"],["@@Symbol.toStringTag:s","ChildProcess:f","_forkChild:f","default:o","exec:f","execFile:f","execFileSync:f","execSync:f","fork:f","spawn:f","spawnSync:f"]],"constants":[["defaultCipherList:s","defaultCoreCipherList:s"],["@@Symbol.toStringTag:s","default:o","defaultCipherList:s","defaultCoreCipherList:s"]],"crypto":[["Certificate:f","Cipheriv:f","Decipheriv:f","DiffieHellman:f","DiffieHellmanGroup:f","ECDH:f","Hash:f","Hmac:f","KeyObject:f","Sign:f","Verify:f","X509Certificate:f","argon2:f","argon2Sync:f","checkPrime:f","checkPrimeSync:f","constants:o","createCipheriv:f","createDecipheriv:f","createDiffieHellman:f","createDiffieHellmanGroup:f","createECDH:f","createHash:f","createHmac:f","createPrivateKey:f","createPublicKey:f","createSecretKey:f","createSign:f","createVerify:f","decapsulate:f","diffieHellman:f","encapsulate:f","fips:a","generateKey:f","generateKeyPair:f","generateKeyPairSync:f","generateKeySync:f","generatePrime:f","generatePrimeSync:f","getCipherInfo:f","getCiphers:f","getCurves:f","getDiffieHellman:f","getFips:f","getHashes:f","getRandomValues:a","hash:f","hkdf:f","hkdfSync:f","pbkdf2:f","pbkdf2Sync:f","privateDecrypt:f","privateEncrypt:f","prng:a","pseudoRandomBytes:a","publicDecrypt:f","publicEncrypt:f","randomBytes:f","randomFill:f","randomFillSync:f","randomInt:f","randomUUID:f","randomUUIDv7:f","rng:a","scrypt:f","scryptSync:f","secureHeapUsed:f","setEngine:f","setFips:f","sign:f","subtle:a","timingSafeEqual:f","verify:f","webcrypto:a"],["@@Symbol.toStringTag:s","Certificate:f","Cipheriv:f","Decipheriv:f","DiffieHellman:f","DiffieHellmanGroup:f","ECDH:f","Hash:f","Hmac:f","KeyObject:f","Sign:f","Verify:f","X509Certificate:f","argon2:f","argon2Sync:f","checkPrime:f","checkPrimeSync:f","constants:o","createCipheriv:f","createDecipheriv:f","createDiffieHellman:f","createDiffieHellmanGroup:f","createECDH:f","createHash:f","createHmac:f","createPrivateKey:f","createPublicKey:f","createSecretKey:f","createSign:f","createVerify:f","decapsulate:f","default:o","diffieHellman:f","encapsulate:f","generateKey:f","generateKeyPair:f","generateKeyPairSync:f","generateKeySync:f","generatePrime:f","generatePrimeSync:f","getCipherInfo:f","getCiphers:f","getCurves:f","getDiffieHellman:f","getFips:f","getHashes:f","getRandomValues:f","hash:f","hkdf:f","hkdfSync:f","pbkdf2:f","pbkdf2Sync:f","privateDecrypt:f","privateEncrypt:f","publicDecrypt:f","publicEncrypt:f","randomBytes:f","randomFill:f","randomFillSync:f","randomInt:f","randomUUID:f","randomUUIDv7:f","scrypt:f","scryptSync:f","secureHeapUsed:f","setEngine:f","setFips:f","sign:f","subtle:o","timingSafeEqual:f","verify:f","webcrypto:o"]],"dgram":[["Socket:f","createSocket:f"],["@@Symbol.toStringTag:s","Socket:f","createSocket:f","default:o"]],"dns":[["ADDRCONFIG:n","ADDRGETNETWORKPARAMS:s","ALL:n","BADFAMILY:s","BADFLAGS:s","BADHINTS:s","BADNAME:s","BADQUERY:s","BADRESP:s","BADSTR:s","CANCELLED:s","CONNREFUSED:s","DESTRUCTION:s","EOF:s","FILE:s","FORMERR:s","LOADIPHLPAPI:s","NODATA:s","NOMEM:s","NONAME:s","NOTFOUND:s","NOTIMP:s","NOTINITIALIZED:s","REFUSED:s","Resolver:f","SERVFAIL:s","TIMEOUT:s","V4MAPPED:n","getDefaultResultOrder:f","getServers:f","lookup:f","lookupService:f","promises:a","resolve4:f","resolve6:f","resolve:f","resolveAny:f","resolveCaa:f","resolveCname:f","resolveMx:f","resolveNaptr:f","resolveNs:f","resolvePtr:f","resolveSoa:f","resolveSrv:f","resolveTlsa:f","resolveTxt:f","reverse:f","setDefaultResultOrder:f","setServers:f"],["@@Symbol.toStringTag:s","ADDRCONFIG:n","ADDRGETNETWORKPARAMS:s","ALL:n","BADFAMILY:s","BADFLAGS:s","BADHINTS:s","BADNAME:s","BADQUERY:s","BADRESP:s","BADSTR:s","CANCELLED:s","CONNREFUSED:s","DESTRUCTION:s","EOF:s","FILE:s","FORMERR:s","LOADIPHLPAPI:s","NODATA:s","NOMEM:s","NONAME:s","NOTFOUND:s","NOTIMP:s","NOTINITIALIZED:s","REFUSED:s","Resolver:f","SERVFAIL:s","TIMEOUT:s","V4MAPPED:n","default:o","getDefaultResultOrder:f","getServers:f","lookup:f","lookupService:f","promises:f","resolve4:f","resolve6:f","resolve:f","resolveAny:f","resolveCaa:f","resolveCname:f","resolveMx:f","resolveNaptr:f","resolveNs:f","resolvePtr:f","resolveSoa:f","resolveSrv:f","resolveTlsa:f","resolveTxt:f","reverse:f","setDefaultResultOrder:f","setServers:f"]],"dns/promises":[["ADDRGETNETWORKPARAMS:s","BADFAMILY:s","BADFLAGS:s","BADHINTS:s","BADNAME:s","BADQUERY:s","BADRESP:s","BADSTR:s","CANCELLED:s","CONNREFUSED:s","DESTRUCTION:s","EOF:s","FILE:s","FORMERR:s","LOADIPHLPAPI:s","NODATA:s","NOMEM:s","NONAME:s","NOTFOUND:s","NOTIMP:s","NOTINITIALIZED:s","REFUSED:s","Resolver:f","SERVFAIL:s","TIMEOUT:s","getDefaultResultOrder:f","getServers:f","lookup:f","lookupService:f","resolve4:f","resolve6:f","resolve:f","resolveAny:f","resolveCaa:f","resolveCname:f","resolveMx:f","resolveNaptr:f","resolveNs:f","resolvePtr:f","resolveSoa:f","resolveSrv:f","resolveTlsa:f","resolveTxt:f","reverse:f","setDefaultResultOrder:f","setServers:f"],["@@Symbol.toStringTag:s","ADDRGETNETWORKPARAMS:s","BADFAMILY:s","BADFLAGS:s","BADHINTS:s","BADNAME:s","BADQUERY:s","BADRESP:s","BADSTR:s","CANCELLED:s","CONNREFUSED:s","DESTRUCTION:s","EOF:s","FILE:s","FORMERR:s","LOADIPHLPAPI:s","NODATA:s","NOMEM:s","NONAME:s","NOTFOUND:s","NOTIMP:s","NOTINITIALIZED:s","REFUSED:s","Resolver:f","SERVFAIL:s","TIMEOUT:s","default:o","getDefaultResultOrder:f","getServers:f","lookup:f","lookupService:f","resolve4:f","resolve6:f","resolve:f","resolveAny:f","resolveCaa:f","resolveCname:f","resolveMx:f","resolveNaptr:f","resolveNs:f","resolvePtr:f","resolveSoa:f","resolveSrv:f","resolveTlsa:f","resolveTxt:f","reverse:f","setDefaultResultOrder:f","setServers:f"]],"domain":[["Domain:f","_stack:o","active:l","create:f","createDomain:f"],["@@Symbol.toStringTag:s","Domain:f","_stack:o","active:l","create:f","createDomain:f","default:o"]],"events":[["EventEmitter:f","EventEmitterAsyncResource:a","addAbortListener:f","captureRejectionSymbol:y","captureRejections:a","defaultMaxListeners:a","errorMonitor:y","getEventListeners:f","getMaxListeners:f","init:f","kMaxEventTargetListeners:y","kMaxEventTargetListenersWarned:y","length:n","listenerCount:f","name:s","on:f","once:f","prototype:o","setMaxListeners:f","usingDomains:b"],["@@Symbol.toStringTag:s","EventEmitter:f","EventEmitterAsyncResource:f","addAbortListener:f","captureRejectionSymbol:y","captureRejections:b","default:f","defaultMaxListeners:n","errorMonitor:y","getEventListeners:f","getMaxListeners:f","init:f","listenerCount:f","on:f","once:f","setMaxListeners:f","usingDomains:b"]],"fs":[["Dir:f","Dirent:f","FileReadStream:a","FileWriteStream:a","ReadStream:a","Stats:f","Utf8Stream:a","WriteStream:a","_toUnixTimestamp:f","access:f","accessSync:f","appendFile:f","appendFileSync:f","chmod:f","chmodSync:f","chown:f","chownSync:f","close:f","closeSync:f","constants:o","copyFile:f","copyFileSync:f","cp:f","cpSync:f","createReadStream:f","createWriteStream:f","exists:f","existsSync:f","fchmod:f","fchmodSync:f","fchown:f","fchownSync:f","fdatasync:f","fdatasyncSync:f","fstat:f","fstatSync:f","fsync:f","fsyncSync:f","ftruncate:f","ftruncateSync:f","futimes:f","futimesSync:f","glob:f","globSync:f","lchmod:u","lchmodSync:u","lchown:f","lchownSync:f","link:f","linkSync:f","lstat:f","lstatSync:f","lutimes:f","lutimesSync:f","mkdir:f","mkdirSync:f","mkdtemp:f","mkdtempDisposableSync:f","mkdtempSync:f","open:f","openAsBlob:f","openSync:f","opendir:f","opendirSync:f","promises:a","read:f","readFile:f","readFileSync:f","readSync:f","readdir:f","readdirSync:f","readlink:f","readlinkSync:f","readv:f","readvSync:f","realpath:f","realpathSync:f","rename:f","renameSync:f","rm:f","rmSync:f","rmdir:f","rmdirSync:f","stat:f","statSync:f","statfs:f","statfsSync:f","symlink:f","symlinkSync:f","truncate:f","truncateSync:f","unlink:f","unlinkSync:f","unwatchFile:f","utimes:f","utimesSync:f","watch:f","watchFile:f","write:f","writeFile:f","writeFileSync:f","writeSync:f","writev:f","writevSync:f"],["@@Symbol.toStringTag:s","Dir:f","Dirent:f","FileReadStream:f","FileWriteStream:f","ReadStream:f","Stats:f","Utf8Stream:f","WriteStream:f","_toUnixTimestamp:f","access:f","accessSync:f","appendFile:f","appendFileSync:f","chmod:f","chmodSync:f","chown:f","chownSync:f","close:f","closeSync:f","constants:o","copyFile:f","copyFileSync:f","cp:f","cpSync:f","createReadStream:f","createWriteStream:f","default:o","exists:f","existsSync:f","fchmod:f","fchmodSync:f","fchown:f","fchownSync:f","fdatasync:f","fdatasyncSync:f","fstat:f","fstatSync:f","fsync:f","fsyncSync:f","ftruncate:f","ftruncateSync:f","futimes:f","futimesSync:f","glob:f","globSync:f","lchmod:u","lchmodSync:u","lchown:f","lchownSync:f","link:f","linkSync:f","lstat:f","lstatSync:f","lutimes:f","lutimesSync:f","mkdir:f","mkdirSync:f","mkdtemp:f","mkdtempDisposableSync:f","mkdtempSync:f","open:f","openAsBlob:f","openSync:f","opendir:f","opendirSync:f","promises:f","read:f","readFile:f","readFileSync:f","readSync:f","readdir:f","readdirSync:f","readlink:f","readlinkSync:f","readv:f","readvSync:f","realpath:f","realpathSync:f","rename:f","renameSync:f","rm:f","rmSync:f","rmdir:f","rmdirSync:f","stat:f","statSync:f","statfs:f","statfsSync:f","symlink:f","symlinkSync:f","truncate:f","truncateSync:f","unlink:f","unlinkSync:f","unwatchFile:f","utimes:f","utimesSync:f","watch:f","watchFile:f","write:f","writeFile:f","writeFileSync:f","writeSync:f","writev:f","writevSync:f"]],"fs/promises":[["access:f","appendFile:f","chmod:f","chown:f","constants:o","copyFile:f","cp:f","glob:f","lchmod:f","lchown:f","link:f","lstat:f","lutimes:f","mkdir:f","mkdtemp:f","mkdtempDisposable:f","open:f","opendir:f","readFile:f","readdir:f","readlink:f","realpath:f","rename:f","rm:f","rmdir:f","stat:f","statfs:f","symlink:f","truncate:f","unlink:f","utimes:f","watch:f","writeFile:f"],["@@Symbol.toStringTag:s","access:f","appendFile:f","chmod:f","chown:f","constants:o","copyFile:f","cp:f","default:o","glob:f","lchmod:f","lchown:f","link:f","lstat:f","lutimes:f","mkdir:f","mkdtemp:f","mkdtempDisposable:f","open:f","opendir:f","readFile:f","readdir:f","readlink:f","realpath:f","rename:f","rm:f","rmdir:f","stat:f","statfs:f","symlink:f","truncate:f","unlink:f","utimes:f","watch:f","writeFile:f"]],"http":[["Agent:f","ClientRequest:f","CloseEvent:a","IncomingMessage:f","METHODS:o","MessageEvent:a","OutgoingMessage:f","STATUS_CODES:o","Server:f","ServerResponse:f","WebSocket:a","_connectionListener:f","createServer:f","get:f","globalAgent:a","maxHeaderSize:a","request:f","setGlobalProxyFromEnv:f","setMaxIdleHTTPParsers:f","validateHeaderName:f","validateHeaderValue:f"],["@@Symbol.toStringTag:s","Agent:f","ClientRequest:f","CloseEvent:f","IncomingMessage:f","METHODS:o","MessageEvent:f","OutgoingMessage:f","STATUS_CODES:o","Server:f","ServerResponse:f","WebSocket:f","_connectionListener:f","createServer:f","default:o","get:f","globalAgent:f","maxHeaderSize:f","request:f","setGlobalProxyFromEnv:f","setMaxIdleHTTPParsers:f","validateHeaderName:f","validateHeaderValue:f"]],"http2":[["Http2ServerRequest:f","Http2ServerResponse:f","connect:f","constants:o","createSecureServer:f","createServer:f","getDefaultSettings:f","getPackedSettings:f","getUnpackedSettings:f","performServerHandshake:f","sensitiveHeaders:y"],["@@Symbol.toStringTag:s","Http2ServerRequest:f","Http2ServerResponse:f","connect:f","constants:o","createSecureServer:f","createServer:f","default:o","getDefaultSettings:f","getPackedSettings:f","getUnpackedSettings:f","performServerHandshake:f","sensitiveHeaders:y"]],"https":[["Agent:f","Server:f","createServer:f","get:f","globalAgent:o","request:f"],["@@Symbol.toStringTag:s","Agent:f","Server:f","createServer:f","default:o","get:f","globalAgent:o","request:f"]],"inspector":[["DOMStorage:o","Network:o","NetworkResources:o","Session:f","close:f","console:o","open:f","url:f","waitForDebugger:f"],["@@Symbol.toStringTag:s","DOMStorage:o","Network:o","NetworkResources:o","Session:f","close:f","console:o","default:o","open:f","url:f","waitForDebugger:f"]],"inspector/promises":[["DOMStorage:o","Network:o","NetworkResources:o","Session:f","close:f","console:o","open:f","url:f","waitForDebugger:f"],["@@Symbol.toStringTag:s","DOMStorage:o","Network:o","NetworkResources:o","Session:f","close:f","console:o","default:o","open:f","url:f","waitForDebugger:f"]],"module":[["Module:f","SourceMap:f","_cache:o","_extensions:o","_findPath:f","_initPaths:f","_load:f","_nodeModulePaths:f","_pathCache:o","_preloadModules:f","_readPackage:a","_resolveFilename:f","_resolveLookupPaths:f","_stat:a","builtinModules:o","constants:o","createRequire:f","enableCompileCache:f","findPackageJSON:f","findSourceMap:f","flushCompileCache:f","getCompileCacheDir:f","getSourceMapsSupport:f","globalPaths:o","isBuiltin:f","length:n","name:s","prototype:o","register:f","registerHooks:f","runMain:f","setSourceMapsSupport:f","stripTypeScriptTypes:f","syncBuiltinESMExports:f","wrap:a","wrapper:a"],["@@Symbol.toStringTag:s","Module:f","SourceMap:f","_cache:o","_extensions:o","_findPath:f","_initPaths:f","_load:f","_nodeModulePaths:f","_pathCache:o","_preloadModules:f","_resolveFilename:f","_resolveLookupPaths:f","builtinModules:o","constants:o","createRequire:f","default:f","enableCompileCache:f","findPackageJSON:f","findSourceMap:f","flushCompileCache:f","getCompileCacheDir:f","getSourceMapsSupport:f","globalPaths:o","isBuiltin:f","register:f","registerHooks:f","runMain:f","setSourceMapsSupport:f","stripTypeScriptTypes:f","syncBuiltinESMExports:f"]],"net":[["BlockList:a","BoundSocket:f","Server:f","Socket:f","SocketAddress:a","Stream:f","_createServerHandle:f","_normalizeArgs:f","connect:f","createConnection:f","createServer:f","getDefaultAutoSelectFamily:f","getDefaultAutoSelectFamilyAttemptTimeout:f","isIP:f","isIPv4:f","isIPv6:f","setDefaultAutoSelectFamily:f","setDefaultAutoSelectFamilyAttemptTimeout:f"],["@@Symbol.toStringTag:s","BlockList:f","BoundSocket:f","Server:f","Socket:f","SocketAddress:f","Stream:f","_createServerHandle:f","_normalizeArgs:f","connect:f","createConnection:f","createServer:f","default:o","getDefaultAutoSelectFamily:f","getDefaultAutoSelectFamilyAttemptTimeout:f","isIP:f","isIPv4:f","isIPv6:f","setDefaultAutoSelectFamily:f","setDefaultAutoSelectFamilyAttemptTimeout:f"]],"node:sea":[["getAsset:f","getAssetAsBlob:f","getAssetKeys:f","getRawAsset:f","isSea:f"],["@@Symbol.toStringTag:s","default:o","getAsset:f","getAssetAsBlob:f","getAssetKeys:f","getRawAsset:f","isSea:f"]],"node:sqlite":[["DatabaseSync:f","Session:f","StatementSync:f","backup:f","constants:o"],["@@Symbol.toStringTag:s","DatabaseSync:f","Session:f","StatementSync:f","backup:f","constants:o","default:o"]],"os":[["EOL:s","arch:f","availableParallelism:f","constants:o","cpus:f","devNull:s","endianness:f","freemem:f","getPriority:f","homedir:f","hostname:f","loadavg:f","machine:f","networkInterfaces:f","platform:f","release:f","setPriority:f","tmpdir:f","totalmem:f","type:f","uptime:f","userInfo:f","version:f"],["@@Symbol.toStringTag:s","EOL:s","arch:f","availableParallelism:f","constants:o","cpus:f","default:o","devNull:s","endianness:f","freemem:f","getPriority:f","homedir:f","hostname:f","loadavg:f","machine:f","networkInterfaces:f","platform:f","release:f","setPriority:f","tmpdir:f","totalmem:f","type:f","uptime:f","userInfo:f","version:f"]],"path":[["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],["@@Symbol.toStringTag:s","_makeLong:f","basename:f","default:o","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"]],"path/posix":[["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],["@@Symbol.toStringTag:s","_makeLong:f","basename:f","default:o","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"]],"path/win32":[["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],["@@Symbol.toStringTag:s","_makeLong:f","basename:f","default:o","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"]],"perf_hooks":[["Performance:f","PerformanceEntry:f","PerformanceMark:f","PerformanceMeasure:f","PerformanceObserver:f","PerformanceObserverEntryList:f","PerformanceResourceTiming:f","constants:o","createHistogram:f","eventLoopUtilization:f","monitorEventLoopDelay:f","performance:o","timerify:f"],["@@Symbol.toStringTag:s","Performance:f","PerformanceEntry:f","PerformanceMark:f","PerformanceMeasure:f","PerformanceObserver:f","PerformanceObserverEntryList:f","PerformanceResourceTiming:f","constants:o","createHistogram:f","default:o","eventLoopUtilization:f","monitorEventLoopDelay:f","performance:o","timerify:f"]],"process":[["@@Symbol.toStringTag:s","@@kCapture:b","@@shapeMode:b","_eval:s","_events:o","_eventsCount:n","_exiting:a","_fatalException:f","_getActiveHandles:f","_getActiveRequests:f","_kill:f","_linkedBinding:f","_maxListeners:u","_preload_modules:o","_rawDebug:f","_tickCallback:f","abort:f","addUncaughtExceptionCaptureCallback:f","allowedNodeEnvironmentFlags:a|o","arch:s","argv0:s","argv:o","availableMemory:f","binding:f","chdir:f","config:o","constrainedMemory:f","cpuUsage:f","cwd:f","debugPort:n","dlopen:f","domain:a","emitWarning:f","env:o","execArgv:o","execPath:s","execve:f","exit:f","exitCode:a","features:o","finalization:a","getActiveResourcesInfo:f","getBuiltinModule:f","getegid:f","geteuid:f","getgid:f","getgroups:f","getuid:f","hasUncaughtExceptionCaptureCallback:f","hrtime:f","initgroups:f","kill:f","loadEnvFile:f","memoryUsage:f","moduleLoadList:o","nextTick:f","openStdin:f","permission:o","pid:n","platform:s","ppid:n","reallyExit:f","ref:f","release:o","report:a","resourceUsage:f","setSourceMapsEnabled:f","setUncaughtExceptionCaptureCallback:f","setegid:f","seteuid:f","setgid:f","setgroups:f","setuid:f","sourceMapsEnabled:a","stderr:a","stdin:a","stdout:a","threadCpuUsage:f","title:s","umask:f","unref:f","uptime:f","version:s","versions:o"],["@@Symbol.toStringTag:s","_eval:s","_events:o","_eventsCount:n","_exiting:b","_fatalException:f","_getActiveHandles:f","_getActiveRequests:f","_kill:f","_linkedBinding:f","_maxListeners:u","_preload_modules:o","_rawDebug:f","_tickCallback:f","abort:f","addUncaughtExceptionCaptureCallback:f","allowedNodeEnvironmentFlags:o","arch:s","argv0:s","argv:o","availableMemory:f","binding:f","chdir:f","config:o","constrainedMemory:f","cpuUsage:f","cwd:f","debugPort:n","default:o","dlopen:f","domain:l","emitWarning:f","env:o","execArgv:o","execPath:s","execve:f","exit:f","exitCode:u","features:o","finalization:o","getActiveResourcesInfo:f","getBuiltinModule:f","getegid:f","geteuid:f","getgid:f","getgroups:f","getuid:f","hasUncaughtExceptionCaptureCallback:f","hrtime:f","initgroups:f","kill:f","loadEnvFile:f","memoryUsage:f","moduleLoadList:o","nextTick:f","openStdin:f","permission:o","pid:n","platform:s","ppid:n","reallyExit:f","ref:f","release:o","report:o","resourceUsage:f","setSourceMapsEnabled:f","setUncaughtExceptionCaptureCallback:f","setegid:f","seteuid:f","setgid:f","setgroups:f","setuid:f","sourceMapsEnabled:b","stderr:o","stdin:o","stdout:o","threadCpuUsage:f","title:s","umask:f","unref:f","uptime:f","version:s","versions:o"]],"punycode":[["decode:f","encode:f","toASCII:f","toUnicode:f","ucs2:o","version:s"],["@@Symbol.toStringTag:s","decode:f","default:o","encode:f","toASCII:f","toUnicode:f","ucs2:o","version:s"]],"querystring":[["decode:f","encode:f","escape:f","parse:f","stringify:f","unescape:f","unescapeBuffer:f"],["@@Symbol.toStringTag:s","decode:f","default:o","encode:f","escape:f","parse:f","stringify:f","unescape:f","unescapeBuffer:f"]],"readline":[["Interface:f","clearLine:f","clearScreenDown:f","createInterface:f","cursorTo:f","emitKeypressEvents:f","moveCursor:f","promises:o"],["@@Symbol.toStringTag:s","Interface:f","clearLine:f","clearScreenDown:f","createInterface:f","cursorTo:f","default:o","emitKeypressEvents:f","moveCursor:f","promises:o"]],"readline/promises":[["Interface:f","Readline:f","createInterface:f"],["@@Symbol.toStringTag:s","Interface:f","Readline:f","createInterface:f","default:o"]],"stream":[["Duplex:f","PassThrough:f","Readable:f","Stream:f","Transform:f","Writable:f","_isArrayBufferView:f","_isUint8Array:f","_uint8ArrayToBuffer:f","addAbortSignal:f","compose:f","destroy:f","duplexPair:f","finished:f","getDefaultHighWaterMark:f","isDestroyed:f","isDisturbed:f","isErrored:f","isReadable:f","isWritable:f","length:n","name:s","pipeline:f","promises:a","prototype:o","setDefaultHighWaterMark:f"],["@@Symbol.toStringTag:s","Duplex:f","PassThrough:f","Readable:f","Stream:f","Transform:f","Writable:f","_isArrayBufferView:f","_isUint8Array:f","_uint8ArrayToBuffer:f","addAbortSignal:f","compose:f","default:f","destroy:f","duplexPair:f","finished:f","getDefaultHighWaterMark:f","isDestroyed:f","isDisturbed:f","isErrored:f","isReadable:f","isWritable:f","pipeline:f","promises:o","setDefaultHighWaterMark:f"]],"stream/consumers":[["arrayBuffer:f","blob:f","buffer:f","bytes:f","json:f","text:f"],["@@Symbol.toStringTag:s","arrayBuffer:f","blob:f","buffer:f","bytes:f","default:o","json:f","text:f"]],"stream/promises":[["finished:f","pipeline:f"],["@@Symbol.toStringTag:s","default:o","finished:f","pipeline:f"]],"stream/web":[["ByteLengthQueuingStrategy:f","CompressionStream:f","CountQueuingStrategy:f","DecompressionStream:f","ReadableByteStreamController:f","ReadableStream:f","ReadableStreamBYOBReader:f","ReadableStreamBYOBRequest:f","ReadableStreamDefaultController:f","ReadableStreamDefaultReader:f","ReadableStreamTee:f","TextDecoderStream:f","TextEncoderStream:f","TransformStream:f","TransformStreamDefaultController:f","WritableStream:f","WritableStreamDefaultController:f","WritableStreamDefaultWriter:f"],["@@Symbol.toStringTag:s","ByteLengthQueuingStrategy:f","CompressionStream:f","CountQueuingStrategy:f","DecompressionStream:f","ReadableByteStreamController:f","ReadableStream:f","ReadableStreamBYOBReader:f","ReadableStreamBYOBRequest:f","ReadableStreamDefaultController:f","ReadableStreamDefaultReader:f","ReadableStreamTee:f","TextDecoderStream:f","TextEncoderStream:f","TransformStream:f","TransformStreamDefaultController:f","WritableStream:f","WritableStreamDefaultController:f","WritableStreamDefaultWriter:f","default:o"]],"string_decoder":[["StringDecoder:f"],["@@Symbol.toStringTag:s","StringDecoder:f","default:o"]],"sys":[["MIMEParams:f","MIMEType:f","TextDecoder:f","TextEncoder:f","_errnoException:f","_exceptionWithHostPort:f","_extend:f","aborted:a","callbackify:f","convertProcessSignalToExitCode:f","debug:f","debuglog:f","deprecate:f","diff:f","format:f","formatWithOptions:f","getCallSites:f","getSystemErrorMap:f","getSystemErrorMessage:f","getSystemErrorName:f","inherits:f","inspect:f","isArray:f","isDeepStrictEqual:f","parseArgs:f","parseEnv:f","promisify:f","setTraceSigInt:f","stripVTControlCharacters:f","styleText:f","toUSVString:f","transferableAbortController:a","transferableAbortSignal:a","types:o"],["@@Symbol.toStringTag:s","MIMEParams:f","MIMEType:f","TextDecoder:f","TextEncoder:f","_errnoException:f","_exceptionWithHostPort:f","_extend:f","aborted:f","callbackify:f","convertProcessSignalToExitCode:f","debug:f","debuglog:f","default:o","deprecate:f","diff:f","format:f","formatWithOptions:f","getCallSites:f","getSystemErrorMap:f","getSystemErrorMessage:f","getSystemErrorName:f","inherits:f","inspect:f","isArray:f","isDeepStrictEqual:f","parseArgs:f","parseEnv:f","promisify:f","setTraceSigInt:f","stripVTControlCharacters:f","styleText:f","toUSVString:f","transferableAbortController:f","transferableAbortSignal:f","types:o"]],"timers":[["clearImmediate:f","clearInterval:f","clearTimeout:f","promises:a","setImmediate:f","setInterval:f","setTimeout:f"],["@@Symbol.toStringTag:s","clearImmediate:f","clearInterval:f","clearTimeout:f","default:o","promises:o","setImmediate:f","setInterval:f","setTimeout:f"]],"timers/promises":[["scheduler:o","setImmediate:f","setInterval:f","setTimeout:f"],["@@Symbol.toStringTag:s","default:o","scheduler:o","setImmediate:f","setInterval:f","setTimeout:f"]],"tls":[["CLIENT_RENEG_LIMIT:n","CLIENT_RENEG_WINDOW:n","DEFAULT_CIPHERS:s","DEFAULT_ECDH_CURVE:s","DEFAULT_MAX_VERSION:s","DEFAULT_MIN_VERSION:s","SecureContext:f","Server:f","TLSSocket:f","checkServerIdentity:f","connect:f","convertALPNProtocols:f","createSecureContext:f","createServer:f","getCACertificates:f","getCertificateCompressionAlgorithms:f","getCiphers:f","rootCertificates:a","setDefaultCACertificates:f"],["@@Symbol.toStringTag:s","CLIENT_RENEG_LIMIT:n","CLIENT_RENEG_WINDOW:n","DEFAULT_CIPHERS:s","DEFAULT_ECDH_CURVE:s","DEFAULT_MAX_VERSION:s","DEFAULT_MIN_VERSION:s","SecureContext:f","Server:f","TLSSocket:f","checkServerIdentity:f","connect:f","convertALPNProtocols:f","createSecureContext:f","createServer:f","default:o","getCACertificates:f","getCertificateCompressionAlgorithms:f","getCiphers:f","rootCertificates:o","setDefaultCACertificates:f"]],"tty":[["ReadStream:f","WriteStream:f","isatty:f"],["@@Symbol.toStringTag:s","ReadStream:f","WriteStream:f","default:o","isatty:f"]],"url":[["URL:f","URLPattern:f","URLSearchParams:f","Url:f","domainToASCII:f","domainToUnicode:f","fileURLToPath:f","fileURLToPathBuffer:f","format:f","parse:f","pathToFileURL:f","resolve:f","resolveObject:f","urlToHttpOptions:f"],["@@Symbol.toStringTag:s","URL:f","URLPattern:f","URLSearchParams:f","Url:f","default:o","domainToASCII:f","domainToUnicode:f","fileURLToPath:f","fileURLToPathBuffer:f","format:f","parse:f","pathToFileURL:f","resolve:f","resolveObject:f","urlToHttpOptions:f"]],"util":[["MIMEParams:f","MIMEType:f","TextDecoder:f","TextEncoder:f","_errnoException:f","_exceptionWithHostPort:f","_extend:f","aborted:a","callbackify:f","convertProcessSignalToExitCode:f","debug:f","debuglog:f","deprecate:f","diff:f","format:f","formatWithOptions:f","getCallSites:f","getSystemErrorMap:f","getSystemErrorMessage:f","getSystemErrorName:f","inherits:f","inspect:f","isArray:f","isDeepStrictEqual:f","parseArgs:f","parseEnv:f","promisify:f","setTraceSigInt:f","stripVTControlCharacters:f","styleText:f","toUSVString:f","transferableAbortController:a","transferableAbortSignal:a","types:o"],["@@Symbol.toStringTag:s","MIMEParams:f","MIMEType:f","TextDecoder:f","TextEncoder:f","_errnoException:f","_exceptionWithHostPort:f","_extend:f","aborted:f","callbackify:f","convertProcessSignalToExitCode:f","debug:f","debuglog:f","default:o","deprecate:f","diff:f","format:f","formatWithOptions:f","getCallSites:f","getSystemErrorMap:f","getSystemErrorMessage:f","getSystemErrorName:f","inherits:f","inspect:f","isArray:f","isDeepStrictEqual:f","parseArgs:f","parseEnv:f","promisify:f","setTraceSigInt:f","stripVTControlCharacters:f","styleText:f","toUSVString:f","transferableAbortController:f","transferableAbortSignal:f","types:o"]],"util/types":[["isAnyArrayBuffer:f","isArgumentsObject:f","isArrayBuffer:f","isArrayBufferView:f","isAsyncFunction:f","isBigInt64Array:f","isBigIntObject:f","isBigUint64Array:f","isBooleanObject:f","isBoxedPrimitive:f","isCryptoKey:f","isDataView:f","isDate:f","isExternal:f","isFloat16Array:f","isFloat32Array:f","isFloat64Array:f","isGeneratorFunction:f","isGeneratorObject:f","isInt16Array:f","isInt32Array:f","isInt8Array:f","isKeyObject:f","isMap:f","isMapIterator:f","isModuleNamespaceObject:f","isNativeError:f","isNumberObject:f","isPromise:f","isProxy:f","isRegExp:f","isSet:f","isSetIterator:f","isSharedArrayBuffer:f","isStringObject:f","isSymbolObject:f","isTypedArray:f","isUint16Array:f","isUint32Array:f","isUint8Array:f","isUint8ClampedArray:f","isWeakMap:f","isWeakSet:f"],["@@Symbol.toStringTag:s","default:o","isAnyArrayBuffer:f","isArgumentsObject:f","isArrayBuffer:f","isArrayBufferView:f","isAsyncFunction:f","isBigInt64Array:f","isBigIntObject:f","isBigUint64Array:f","isBooleanObject:f","isBoxedPrimitive:f","isCryptoKey:f","isDataView:f","isDate:f","isExternal:f","isFloat16Array:f","isFloat32Array:f","isFloat64Array:f","isGeneratorFunction:f","isGeneratorObject:f","isInt16Array:f","isInt32Array:f","isInt8Array:f","isKeyObject:f","isMap:f","isMapIterator:f","isModuleNamespaceObject:f","isNativeError:f","isNumberObject:f","isPromise:f","isProxy:f","isRegExp:f","isSet:f","isSetIterator:f","isSharedArrayBuffer:f","isStringObject:f","isSymbolObject:f","isTypedArray:f","isUint16Array:f","isUint32Array:f","isUint8Array:f","isUint8ClampedArray:f","isWeakMap:f","isWeakSet:f"]],"v8":[["DefaultDeserializer:f","DefaultSerializer:f","Deserializer:f","GCProfiler:f","Serializer:f","cachedDataVersionTag:f","deserialize:f","getCppHeapStatistics:f","getHeapCodeStatistics:f","getHeapSnapshot:f","getHeapSpaceStatistics:f","getHeapStatistics:f","isStringOneByteRepresentation:f","promiseHooks:o","queryObjects:f","serialize:f","setFlagsFromString:f","setHeapSnapshotNearHeapLimit:f","startCpuProfile:f","startHeapProfile:f","startupSnapshot:o","stopCoverage:f","takeCoverage:f","writeHeapSnapshot:f"],["@@Symbol.toStringTag:s","DefaultDeserializer:f","DefaultSerializer:f","Deserializer:f","GCProfiler:f","Serializer:f","cachedDataVersionTag:f","default:o","deserialize:f","getCppHeapStatistics:f","getHeapCodeStatistics:f","getHeapSnapshot:f","getHeapSpaceStatistics:f","getHeapStatistics:f","isStringOneByteRepresentation:f","promiseHooks:o","queryObjects:f","serialize:f","setFlagsFromString:f","setHeapSnapshotNearHeapLimit:f","startCpuProfile:f","startHeapProfile:f","startupSnapshot:o","stopCoverage:f","takeCoverage:f","writeHeapSnapshot:f"]],"vm":[["Script:f","compileFunction:f","constants:o","createContext:f","createScript:f","isContext:f","measureMemory:f","runInContext:f","runInNewContext:f","runInThisContext:f"],["@@Symbol.toStringTag:s","Script:f","compileFunction:f","constants:o","createContext:f","createScript:f","default:o","isContext:f","measureMemory:f","runInContext:f","runInNewContext:f","runInThisContext:f"]],"wasi":[["WASI:f"],["@@Symbol.toStringTag:s","WASI:f","default:o"]],"worker_threads":[["BroadcastChannel:f","MessageChannel:f","MessagePort:f","SHARE_ENV:y","Worker:f","getEnvironmentData:f","isInternalThread:b","isMainThread:b","isMarkedAsUntransferable:f","locks:o","markAsUncloneable:f","markAsUntransferable:f","moveMessagePortToContext:f","parentPort:o","postMessageToThread:f","receiveMessageOnPort:f","resourceLimits:o","setEnvironmentData:f","threadId:n","threadName:s","workerData:o"],["@@Symbol.toStringTag:s","BroadcastChannel:f","MessageChannel:f","MessagePort:f","SHARE_ENV:y","Worker:f","default:o","getEnvironmentData:f","isInternalThread:b","isMainThread:b","isMarkedAsUntransferable:f","locks:o","markAsUncloneable:f","markAsUntransferable:f","moveMessagePortToContext:f","parentPort:l","postMessageToThread:f","receiveMessageOnPort:f","resourceLimits:o","setEnvironmentData:f","threadId:n","threadName:s","workerData:u"]],"zlib":[["BrotliCompress:f","BrotliDecompress:f","DEFLATE:n","DEFLATERAW:n","Deflate:f","DeflateRaw:f","GUNZIP:n","GZIP:n","Gunzip:f","Gzip:f","INFLATE:n","INFLATERAW:n","Inflate:f","InflateRaw:f","UNZIP:n","Unzip:f","ZLIB_VERNUM:n","ZSTD_CLEVEL_DEFAULT:n","ZSTD_COMPRESS:n","ZSTD_DECOMPRESS:n","ZSTD_btlazy2:n","ZSTD_btopt:n","ZSTD_btultra2:n","ZSTD_btultra:n","ZSTD_c_chainLog:n","ZSTD_c_checksumFlag:n","ZSTD_c_compressionLevel:n","ZSTD_c_contentSizeFlag:n","ZSTD_c_dictIDFlag:n","ZSTD_c_enableLongDistanceMatching:n","ZSTD_c_hashLog:n","ZSTD_c_jobSize:n","ZSTD_c_ldmBucketSizeLog:n","ZSTD_c_ldmHashLog:n","ZSTD_c_ldmHashRateLog:n","ZSTD_c_ldmMinMatch:n","ZSTD_c_minMatch:n","ZSTD_c_nbWorkers:n","ZSTD_c_overlapLog:n","ZSTD_c_searchLog:n","ZSTD_c_strategy:n","ZSTD_c_targetLength:n","ZSTD_c_windowLog:n","ZSTD_d_windowLogMax:n","ZSTD_dfast:n","ZSTD_e_continue:n","ZSTD_e_end:n","ZSTD_e_flush:n","ZSTD_error_GENERIC:n","ZSTD_error_checksum_wrong:n","ZSTD_error_corruption_detected:n","ZSTD_error_dictionaryCreation_failed:n","ZSTD_error_dictionary_corrupted:n","ZSTD_error_dictionary_wrong:n","ZSTD_error_dstBuffer_null:n","ZSTD_error_dstSize_tooSmall:n","ZSTD_error_frameParameter_unsupported:n","ZSTD_error_frameParameter_windowTooLarge:n","ZSTD_error_init_missing:n","ZSTD_error_literals_headerWrong:n","ZSTD_error_maxSymbolValue_tooLarge:n","ZSTD_error_maxSymbolValue_tooSmall:n","ZSTD_error_memory_allocation:n","ZSTD_error_noForwardProgress_destFull:n","ZSTD_error_noForwardProgress_inputEmpty:n","ZSTD_error_no_error:n","ZSTD_error_parameter_combination_unsupported:n","ZSTD_error_parameter_outOfBound:n","ZSTD_error_parameter_unsupported:n","ZSTD_error_prefix_unknown:n","ZSTD_error_srcSize_wrong:n","ZSTD_error_stabilityCondition_notRespected:n","ZSTD_error_stage_wrong:n","ZSTD_error_tableLog_tooLarge:n","ZSTD_error_version_unsupported:n","ZSTD_error_workSpace_tooSmall:n","ZSTD_fast:n","ZSTD_greedy:n","ZSTD_lazy2:n","ZSTD_lazy:n","Z_BEST_COMPRESSION:n","Z_BEST_SPEED:n","Z_BLOCK:n","Z_BUF_ERROR:n","Z_DATA_ERROR:n","Z_DEFAULT_CHUNK:n","Z_DEFAULT_COMPRESSION:n","Z_DEFAULT_LEVEL:n","Z_DEFAULT_MEMLEVEL:n","Z_DEFAULT_STRATEGY:n","Z_DEFAULT_WINDOWBITS:n","Z_ERRNO:n","Z_FILTERED:n","Z_FINISH:n","Z_FIXED:n","Z_FULL_FLUSH:n","Z_HUFFMAN_ONLY:n","Z_MAX_CHUNK:n","Z_MAX_LEVEL:n","Z_MAX_MEMLEVEL:n","Z_MAX_WINDOWBITS:n","Z_MEM_ERROR:n","Z_MIN_CHUNK:n","Z_MIN_LEVEL:n","Z_MIN_MEMLEVEL:n","Z_MIN_WINDOWBITS:n","Z_NEED_DICT:n","Z_NO_COMPRESSION:n","Z_NO_FLUSH:n","Z_OK:n","Z_PARTIAL_FLUSH:n","Z_RLE:n","Z_STREAM_END:n","Z_STREAM_ERROR:n","Z_SYNC_FLUSH:n","Z_VERSION_ERROR:n","ZstdCompress:f","ZstdDecompress:f","brotliCompress:f","brotliCompressSync:f","brotliDecompress:f","brotliDecompressSync:f","codes:o","constants:o","crc32:f","createBrotliCompress:f","createBrotliDecompress:f","createDeflate:f","createDeflateRaw:f","createGunzip:f","createGzip:f","createInflate:f","createInflateRaw:f","createUnzip:f","createZstdCompress:f","createZstdDecompress:f","deflate:f","deflateRaw:f","deflateRawSync:f","deflateSync:f","gunzip:f","gunzipSync:f","gzip:f","gzipSync:f","inflate:f","inflateRaw:f","inflateRawSync:f","inflateSync:f","unzip:f","unzipSync:f","zstdCompress:f","zstdCompressSync:f","zstdDecompress:f","zstdDecompressSync:f"],["@@Symbol.toStringTag:s","BrotliCompress:f","BrotliDecompress:f","Deflate:f","DeflateRaw:f","Gunzip:f","Gzip:f","Inflate:f","InflateRaw:f","Unzip:f","ZstdCompress:f","ZstdDecompress:f","brotliCompress:f","brotliCompressSync:f","brotliDecompress:f","brotliDecompressSync:f","codes:o","constants:o","crc32:f","createBrotliCompress:f","createBrotliDecompress:f","createDeflate:f","createDeflateRaw:f","createGunzip:f","createGzip:f","createInflate:f","createInflateRaw:f","createUnzip:f","createZstdCompress:f","createZstdDecompress:f","default:o","deflate:f","deflateRaw:f","deflateRawSync:f","deflateSync:f","gunzip:f","gunzipSync:f","gzip:f","gzipSync:f","inflate:f","inflateRaw:f","inflateRawSync:f","inflateSync:f","unzip:f","unzipSync:f","zstdCompress:f","zstdCompressSync:f","zstdDecompress:f","zstdDecompressSync:f"]]}) + +export const NODE_BUILTIN_SURFACE_FROM_26_8 = Object.freeze({"constants":[[],[]],"zlib":[["ZipBuffer:f","ZipEntry:f","ZipFile:f","createZipArchive:f","createZipArchiveSync:f","getMaxZipContentSize:f","setMaxZipContentSize:f","zipFiles:f"],["ZipBuffer:f","ZipEntry:f","ZipFile:f","createZipArchive:f","createZipArchiveSync:f","getMaxZipContentSize:f","setMaxZipContentSize:f","zipFiles:f"]]}) + +export const NODE_BUILTIN_SURFACE_FROM_26_9 = Object.freeze({"crypto":[["createMac:f","getMacs:f"],["createMac:f","getMacs:f"]],"perf_hooks":[["importHistogram:f"],["importHistogram:f"]],"v8":[["setHeapProfileNearHeapLimit:f"],["setHeapProfileNearHeapLimit:f"]]}) + +// Guest-reachable direct objects and exported constructor/function surfaces. +export const NODE_BUILTIN_GRAPH_BASE = Object.freeze({"assert":{"assert.prototype":["constructor:f"],"assert.AssertionError[[Function]]":["length:n","name:s","prototype:o"],"assert.AssertionError.prototype":["@@nodejs.util.inspect.custom:f","constructor:f","toString:f"],"assert.ok[[Function]]":["length:n","name:s","prototype:o"],"assert.ok.prototype":["constructor:f"],"assert.fail[[Function]]":["length:n","name:s","prototype:o"],"assert.fail.prototype":["constructor:f"],"assert.equal[[Function]]":["length:n","name:s","prototype:o"],"assert.equal.prototype":["constructor:f"],"assert.notEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.notEqual.prototype":["constructor:f"],"assert.deepEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.deepEqual.prototype":["constructor:f"],"assert.notDeepEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.notDeepEqual.prototype":["constructor:f"],"assert.deepStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.deepStrictEqual.prototype":["constructor:f"],"assert.notDeepStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.notDeepStrictEqual.prototype":["constructor:f"],"assert.strictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.strictEqual.prototype":["constructor:f"],"assert.notStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.notStrictEqual.prototype":["constructor:f"],"assert.partialDeepStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert.partialDeepStrictEqual.prototype":["constructor:f"],"assert.match[[Function]]":["length:n","name:s","prototype:o"],"assert.match.prototype":["constructor:f"],"assert.doesNotMatch[[Function]]":["length:n","name:s","prototype:o"],"assert.doesNotMatch.prototype":["constructor:f"],"assert.throws[[Function]]":["length:n","name:s","prototype:o"],"assert.throws.prototype":["constructor:f"],"assert.rejects[[Function]]":["length:n","name:s"],"assert.doesNotThrow[[Function]]":["length:n","name:s","prototype:o"],"assert.doesNotThrow.prototype":["constructor:f"],"assert.doesNotReject[[Function]]":["length:n","name:s"],"assert.ifError[[Function]]":["length:n","name:s","prototype:o"],"assert.ifError.prototype":["constructor:f"],"assert.strict[[Function]]":["Assert:f","AssertionError:f","deepEqual:f","deepStrictEqual:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","length:n","match:f","name:s","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","prototype:o","rejects:f","strict:f","strictEqual:f","throws:f"],"assert.strict.prototype":["constructor:f"],"assert.Assert[[Function]]":["length:n","name:s","prototype:o"],"assert.Assert.prototype":["constructor:f","deepEqual:f","deepStrictEqual:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","match:f","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","rejects:f","strictEqual:f","throws:f"]},"assert/strict":{"assert/strict.prototype":["constructor:f"],"assert/strict.AssertionError[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.AssertionError.prototype":["@@nodejs.util.inspect.custom:f","constructor:f","toString:f"],"assert/strict.ok[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.ok.prototype":["constructor:f"],"assert/strict.fail[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.fail.prototype":["constructor:f"],"assert/strict.equal[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.equal.prototype":["constructor:f"],"assert/strict.notEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.notEqual.prototype":["constructor:f"],"assert/strict.deepEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.deepEqual.prototype":["constructor:f"],"assert/strict.notDeepEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.notDeepEqual.prototype":["constructor:f"],"assert/strict.deepStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.deepStrictEqual.prototype":["constructor:f"],"assert/strict.notDeepStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.notDeepStrictEqual.prototype":["constructor:f"],"assert/strict.strictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.strictEqual.prototype":["constructor:f"],"assert/strict.notStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.notStrictEqual.prototype":["constructor:f"],"assert/strict.partialDeepStrictEqual[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.partialDeepStrictEqual.prototype":["constructor:f"],"assert/strict.match[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.match.prototype":["constructor:f"],"assert/strict.doesNotMatch[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.doesNotMatch.prototype":["constructor:f"],"assert/strict.throws[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.throws.prototype":["constructor:f"],"assert/strict.rejects[[Function]]":["length:n","name:s"],"assert/strict.doesNotThrow[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.doesNotThrow.prototype":["constructor:f"],"assert/strict.doesNotReject[[Function]]":["length:n","name:s"],"assert/strict.ifError[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.ifError.prototype":["constructor:f"],"assert/strict.Assert[[Function]]":["length:n","name:s","prototype:o"],"assert/strict.Assert.prototype":["constructor:f","deepEqual:f","deepStrictEqual:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","match:f","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","rejects:f","strictEqual:f","throws:f"],"assert/strict.strict[[Function]]":["Assert:f","AssertionError:f","deepEqual:f","deepStrictEqual:f","doesNotMatch:f","doesNotReject:f","doesNotThrow:f","equal:f","fail:f","ifError:f","length:n","match:f","name:s","notDeepEqual:f","notDeepStrictEqual:f","notEqual:f","notStrictEqual:f","ok:f","partialDeepStrictEqual:f","prototype:o","rejects:f","strict:f","strictEqual:f","throws:f"],"assert/strict.strict.prototype":["constructor:f"]},"async_hooks":{"async_hooks.AsyncLocalStorage[[Function]]":["length:n","name:s","prototype:o"],"async_hooks.AsyncLocalStorage.prototype":["constructor:f"],"async_hooks.createHook[[Function]]":["length:n","name:s","prototype:o"],"async_hooks.createHook.prototype":["constructor:f"],"async_hooks.executionAsyncId[[Function]]":["length:n","name:s","prototype:o"],"async_hooks.executionAsyncId.prototype":["constructor:f"],"async_hooks.triggerAsyncId[[Function]]":["length:n","name:s","prototype:o"],"async_hooks.triggerAsyncId.prototype":["constructor:f"],"async_hooks.executionAsyncResource[[Function]]":["length:n","name:s","prototype:o"],"async_hooks.executionAsyncResource.prototype":["constructor:f"],"async_hooks.asyncWrapProviders":["ARGON2REQUEST:n","BLOBREADER:n","CHECKPRIMEREQUEST:n","CIPHERREQUEST:n","DERIVEBITSREQUEST:n","DIRHANDLE:n","DNSCHANNEL:n","ELDHISTOGRAM:n","FILEHANDLE:n","FILEHANDLECLOSEREQ:n","FSEVENTWRAP:n","FSREQCALLBACK:n","FSREQPROMISE:n","GETADDRINFOREQWRAP:n","GETNAMEINFOREQWRAP:n","HASHREQUEST:n","HEAPSNAPSHOT:n","HTTP2PING:n","HTTP2SESSION:n","HTTP2SETTINGS:n","HTTP2STREAM:n","HTTPCLIENTREQUEST:n","HTTPINCOMINGMESSAGE:n","JSSTREAM:n","JSUDPWRAP:n","KEYEXPORTREQUEST:n","KEYGENREQUEST:n","KEYPAIRGENREQUEST:n","LOCKS:n","MESSAGEPORT:n","NONE:n","PBKDF2REQUEST:n","PIPECONNECTWRAP:n","PIPESERVERWRAP:n","PIPEWRAP:n","PROCESSWRAP:n","PROMISE:n","QUERYWRAP:n","QUIC_ENDPOINT:n","QUIC_LOGSTREAM:n","QUIC_SESSION:n","QUIC_STREAM:n","QUIC_UDP:n","RANDOMBYTESREQUEST:n","RANDOMPRIMEREQUEST:n","SCRYPTREQUEST:n","SHUTDOWNWRAP:n","SIGINTWATCHDOG:n","SIGNALWRAP:n","SIGNREQUEST:n","STATWATCHER:n","STREAMPIPE:n","TCPCONNECTWRAP:n","TCPSERVERWRAP:n","TCPWRAP:n","TLSWRAP:n","TTYWRAP:n","UDPSENDWRAP:n","UDPWRAP:n","VERIFYREQUEST:n","WORKER:n","WORKERCPUPROFILE:n","WORKERCPUUSAGE:n","WORKERHEAPPROFILE:n","WORKERHEAPSNAPSHOT:n","WORKERHEAPSTATISTICS:n","WRITEWRAP:n","ZLIB:n"],"async_hooks.AsyncResource[[Function]]":["length:n","name:s","prototype:o"],"async_hooks.AsyncResource.prototype":["constructor:f"]},"buffer":{"buffer.Buffer[[Function]]":["@@Symbol.species:a","@@kIsEncodingSymbol:f","alloc:f","allocUnsafe:f","allocUnsafeSlow:f","byteLength:f","compare:f","concat:f","copyBytesFrom:f","from:f","isBuffer:f","isEncoding:f","length:n","name:s","of:f","poolSize:n","prototype:o"],"buffer.Buffer.prototype":["@@nodejs.util.inspect.custom:f","asciiSlice:f","asciiWrite:f","base64Slice:f","base64Write:f","base64urlSlice:f","base64urlWrite:f","compare:f","constructor:f","copy:f","equals:f","fill:f","hexSlice:f","hexWrite:f","includes:f","indexOf:f","inspect:f","lastIndexOf:f","latin1Slice:f","latin1Write:f","offset:a","parent:a","readBigInt64BE:f","readBigInt64LE:f","readBigUInt64BE:f","readBigUInt64LE:f","readBigUint64BE:f","readBigUint64LE:f","readDoubleBE:f","readDoubleLE:f","readFloatBE:f","readFloatLE:f","readInt16BE:f","readInt16LE:f","readInt32BE:f","readInt32LE:f","readInt8:f","readIntBE:f","readIntLE:f","readUInt16BE:f","readUInt16LE:f","readUInt32BE:f","readUInt32LE:f","readUInt8:f","readUIntBE:f","readUIntLE:f","readUint16BE:f","readUint16LE:f","readUint32BE:f","readUint32LE:f","readUint8:f","readUintBE:f","readUintLE:f","slice:f","subarray:f","swap16:f","swap32:f","swap64:f","toJSON:f","toLocaleString:f","toString:f","ucs2Slice:f","ucs2Write:f","utf8Slice:f","utf8Write:f","write:f","writeBigInt64BE:f","writeBigInt64LE:f","writeBigUInt64BE:f","writeBigUInt64LE:f","writeBigUint64BE:f","writeBigUint64LE:f","writeDoubleBE:f","writeDoubleLE:f","writeFloatBE:f","writeFloatLE:f","writeInt16BE:f","writeInt16LE:f","writeInt32BE:f","writeInt32LE:f","writeInt8:f","writeIntBE:f","writeIntLE:f","writeUInt16BE:f","writeUInt16LE:f","writeUInt32BE:f","writeUInt32LE:f","writeUInt8:f","writeUIntBE:f","writeUIntLE:f","writeUint16BE:f","writeUint16LE:f","writeUint32BE:f","writeUint32LE:f","writeUint8:f","writeUintBE:f","writeUintLE:f"],"buffer.transcode[[Function]]":["length:n","name:s","prototype:o"],"buffer.transcode.prototype":["constructor:f"],"buffer.isUtf8[[Function]]":["length:n","name:s","prototype:o"],"buffer.isUtf8.prototype":["constructor:f"],"buffer.isAscii[[Function]]":["length:n","name:s","prototype:o"],"buffer.isAscii.prototype":["constructor:f"],"buffer.btoa[[Function]]":["length:n","name:s","prototype:o"],"buffer.btoa.prototype":["constructor:f"],"buffer.atob[[Function]]":["length:n","name:s","prototype:o"],"buffer.atob.prototype":["constructor:f"],"buffer.constants":[],"buffer.Blob[[Function]]":["length:n","name:s","prototype:o"],"buffer.Blob.prototype":["@@Symbol.toStringTag:s","@@messaging_clone_symbol:f","@@messaging_deserialize_symbol:f","@@nodejs.util.inspect.custom:f","arrayBuffer:f","bytes:f","constructor:f","size:a","slice:f","stream:f","text:f","textStream:f","type:a"],"buffer.resolveObjectURL[[Function]]":["length:n","name:s","prototype:o"],"buffer.resolveObjectURL.prototype":["constructor:f"],"buffer.File[[Function]]":["length:n","name:s","prototype:o"],"buffer.File.prototype":["@@Symbol.toStringTag:s","@@messaging_clone_symbol:f","@@messaging_deserialize_symbol:f","@@nodejs.util.inspect.custom:f","constructor:f","lastModified:a","name:a"],"buffer.File.prototype[[Prototype]]0":["@@Symbol.toStringTag:s","@@messaging_clone_symbol:f","@@messaging_deserialize_symbol:f","@@nodejs.util.inspect.custom:f","arrayBuffer:f","bytes:f","constructor:f","size:a","slice:f","stream:f","text:f","textStream:f","type:a"]},"child_process":{"child_process._forkChild[[Function]]":["length:n","name:s","prototype:o"],"child_process._forkChild.prototype":["constructor:f"],"child_process.ChildProcess[[Function]]":["length:n","name:s","prototype:o"],"child_process.ChildProcess.prototype":["constructor:f"],"child_process.exec[[Function]]":["length:n","name:s","prototype:o"],"child_process.exec.prototype":["constructor:f"],"child_process.execFile[[Function]]":["length:n","name:s","prototype:o"],"child_process.execFile.prototype":["constructor:f"],"child_process.execFileSync[[Function]]":["length:n","name:s","prototype:o"],"child_process.execFileSync.prototype":["constructor:f"],"child_process.execSync[[Function]]":["length:n","name:s","prototype:o"],"child_process.execSync.prototype":["constructor:f"],"child_process.fork[[Function]]":["length:n","name:s","prototype:o"],"child_process.fork.prototype":["constructor:f"],"child_process.spawn[[Function]]":["length:n","name:s","prototype:o"],"child_process.spawn.prototype":["constructor:f"],"child_process.spawnSync[[Function]]":["length:n","name:s","prototype:o"],"child_process.spawnSync.prototype":["constructor:f"]},"constants":{},"crypto":{"crypto.argon2[[Function]]":["length:n","name:s","prototype:o"],"crypto.argon2.prototype":["constructor:f"],"crypto.argon2Sync[[Function]]":["length:n","name:s","prototype:o"],"crypto.argon2Sync.prototype":["constructor:f"],"crypto.checkPrime[[Function]]":["length:n","name:s","prototype:o"],"crypto.checkPrime.prototype":["constructor:f"],"crypto.checkPrimeSync[[Function]]":["length:n","name:s","prototype:o"],"crypto.checkPrimeSync.prototype":["constructor:f"],"crypto.createCipheriv[[Function]]":["length:n","name:s","prototype:o"],"crypto.createCipheriv.prototype":["constructor:f"],"crypto.createDecipheriv[[Function]]":["length:n","name:s","prototype:o"],"crypto.createDecipheriv.prototype":["constructor:f"],"crypto.createDiffieHellman[[Function]]":["length:n","name:s","prototype:o"],"crypto.createDiffieHellman.prototype":["constructor:f"],"crypto.createDiffieHellmanGroup[[Function]]":["length:n","name:s","prototype:o"],"crypto.createDiffieHellmanGroup.prototype":["constructor:f"],"crypto.createECDH[[Function]]":["length:n","name:s","prototype:o"],"crypto.createECDH.prototype":["constructor:f"],"crypto.createHash[[Function]]":["length:n","name:s","prototype:o"],"crypto.createHash.prototype":["constructor:f"],"crypto.createHmac[[Function]]":["length:n","name:s","prototype:o"],"crypto.createHmac.prototype":["constructor:f"],"crypto.createPrivateKey[[Function]]":["length:n","name:s","prototype:o"],"crypto.createPrivateKey.prototype":["constructor:f"],"crypto.createPublicKey[[Function]]":["length:n","name:s","prototype:o"],"crypto.createPublicKey.prototype":["constructor:f"],"crypto.createSecretKey[[Function]]":["length:n","name:s","prototype:o"],"crypto.createSecretKey.prototype":["constructor:f"],"crypto.createSign[[Function]]":["length:n","name:s","prototype:o"],"crypto.createSign.prototype":["constructor:f"],"crypto.createVerify[[Function]]":["length:n","name:s","prototype:o"],"crypto.createVerify.prototype":["constructor:f"],"crypto.diffieHellman[[Function]]":["length:n","name:s","prototype:o"],"crypto.diffieHellman.prototype":["constructor:f"],"crypto.generatePrime[[Function]]":["length:n","name:s","prototype:o"],"crypto.generatePrime.prototype":["constructor:f"],"crypto.generatePrimeSync[[Function]]":["length:n","name:s","prototype:o"],"crypto.generatePrimeSync.prototype":["constructor:f"],"crypto.getCiphers[[Function]]":["length:n","name:s"],"crypto.getCipherInfo[[Function]]":["length:n","name:s","prototype:o"],"crypto.getCipherInfo.prototype":["constructor:f"],"crypto.getCurves[[Function]]":["length:n","name:s"],"crypto.getDiffieHellman[[Function]]":["length:n","name:s","prototype:o"],"crypto.getDiffieHellman.prototype":["constructor:f"],"crypto.getHashes[[Function]]":["length:n","name:s"],"crypto.hkdf[[Function]]":["length:n","name:s","prototype:o"],"crypto.hkdf.prototype":["constructor:f"],"crypto.hkdfSync[[Function]]":["length:n","name:s","prototype:o"],"crypto.hkdfSync.prototype":["constructor:f"],"crypto.pbkdf2[[Function]]":["length:n","name:s","prototype:o"],"crypto.pbkdf2.prototype":["constructor:f"],"crypto.pbkdf2Sync[[Function]]":["length:n","name:s","prototype:o"],"crypto.pbkdf2Sync.prototype":["constructor:f"],"crypto.generateKeyPair[[Function]]":["@@customPromisifyArgs:o","length:n","name:s","prototype:o"],"crypto.generateKeyPair.prototype":["constructor:f"],"crypto.generateKeyPairSync[[Function]]":["length:n","name:s","prototype:o"],"crypto.generateKeyPairSync.prototype":["constructor:f"],"crypto.generateKey[[Function]]":["length:n","name:s","prototype:o"],"crypto.generateKey.prototype":["constructor:f"],"crypto.generateKeySync[[Function]]":["length:n","name:s","prototype:o"],"crypto.generateKeySync.prototype":["constructor:f"],"crypto.privateDecrypt[[Function]]":["length:n","name:s"],"crypto.privateEncrypt[[Function]]":["length:n","name:s"],"crypto.publicDecrypt[[Function]]":["length:n","name:s"],"crypto.publicEncrypt[[Function]]":["length:n","name:s"],"crypto.randomBytes[[Function]]":["length:n","name:s","prototype:o"],"crypto.randomBytes.prototype":["constructor:f"],"crypto.randomFill[[Function]]":["length:n","name:s","prototype:o"],"crypto.randomFill.prototype":["constructor:f"],"crypto.randomFillSync[[Function]]":["length:n","name:s","prototype:o"],"crypto.randomFillSync.prototype":["constructor:f"],"crypto.randomInt[[Function]]":["length:n","name:s","prototype:o"],"crypto.randomInt.prototype":["constructor:f"],"crypto.randomUUID[[Function]]":["length:n","name:s","prototype:o"],"crypto.randomUUID.prototype":["constructor:f"],"crypto.randomUUIDv7[[Function]]":["length:n","name:s","prototype:o"],"crypto.randomUUIDv7.prototype":["constructor:f"],"crypto.scrypt[[Function]]":["length:n","name:s","prototype:o"],"crypto.scrypt.prototype":["constructor:f"],"crypto.scryptSync[[Function]]":["length:n","name:s","prototype:o"],"crypto.scryptSync.prototype":["constructor:f"],"crypto.sign[[Function]]":["length:n","name:s","prototype:o"],"crypto.sign.prototype":["constructor:f"],"crypto.setEngine[[Function]]":["length:n","name:s"],"crypto.timingSafeEqual[[Function]]":["length:n","name:s"],"crypto.getFips[[Function]]":["length:n","name:s","prototype:o"],"crypto.getFips.prototype":["constructor:f"],"crypto.setFips[[Function]]":["length:n","name:s"],"crypto.verify[[Function]]":["length:n","name:s","prototype:o"],"crypto.verify.prototype":["constructor:f"],"crypto.hash[[Function]]":["length:n","name:s","prototype:o"],"crypto.hash.prototype":["constructor:f"],"crypto.encapsulate[[Function]]":["length:n","name:s","prototype:o"],"crypto.encapsulate.prototype":["constructor:f"],"crypto.decapsulate[[Function]]":["length:n","name:s","prototype:o"],"crypto.decapsulate.prototype":["constructor:f"],"crypto.Certificate[[Function]]":["exportChallenge:f","exportPublicKey:f","length:n","name:s","prototype:o","verifySpkac:f"],"crypto.Certificate.prototype":["constructor:f","exportChallenge:f","exportPublicKey:f","verifySpkac:f"],"crypto.Cipheriv[[Function]]":["length:n","name:s","prototype:o"],"crypto.Cipheriv.prototype":["_flush:f","_transform:f","constructor:f","final:f","getAuthTag:f","setAAD:f","setAutoPadding:f","update:f"],"crypto.Cipheriv.prototype[[Prototype]]0":["_readableState:a","_writableState:a","constructor:f"],"crypto.Cipheriv.prototype[[Prototype]]1":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"crypto.Cipheriv.prototype[[Prototype]]2":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"crypto.Cipheriv.prototype[[Prototype]]3":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"crypto.Cipheriv.prototype[[Prototype]]4":["constructor:f","eventNames:f","pipe:f"],"crypto.Cipheriv.prototype[[Prototype]]5":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"crypto.Decipheriv[[Function]]":["length:n","name:s","prototype:o"],"crypto.Decipheriv.prototype":["_flush:f","_transform:f","constructor:f","final:f","setAAD:f","setAuthTag:f","setAutoPadding:f","update:f"],"crypto.Decipheriv.prototype[[Prototype]]0":["_readableState:a","_writableState:a","constructor:f"],"crypto.Decipheriv.prototype[[Prototype]]1":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"crypto.Decipheriv.prototype[[Prototype]]2":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"crypto.Decipheriv.prototype[[Prototype]]3":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"crypto.Decipheriv.prototype[[Prototype]]4":["constructor:f","eventNames:f","pipe:f"],"crypto.Decipheriv.prototype[[Prototype]]5":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"crypto.DiffieHellman[[Function]]":["length:n","name:s","prototype:o"],"crypto.DiffieHellman.prototype":["computeSecret:f","constructor:f","generateKeys:f","getGenerator:f","getPrime:f","getPrivateKey:f","getPublicKey:f","setPrivateKey:f","setPublicKey:f"],"crypto.DiffieHellmanGroup[[Function]]":["length:n","name:s","prototype:o"],"crypto.DiffieHellmanGroup.prototype":["computeSecret:f","constructor:f","generateKeys:f","getGenerator:f","getPrime:f","getPrivateKey:f","getPublicKey:f"],"crypto.ECDH[[Function]]":["convertKey:f","length:n","name:s","prototype:o"],"crypto.ECDH.prototype":["computeSecret:f","constructor:f","generateKeys:f","getPrivateKey:f","getPublicKey:f","setPrivateKey:f","setPublicKey:f"],"crypto.Hash[[Function]]":["length:n","name:s","prototype:o"],"crypto.Hash.prototype":["_flush:f","_transform:f","constructor:f","copy:f","digest:f","update:f"],"crypto.Hash.prototype[[Prototype]]0":["_readableState:a","_writableState:a","constructor:f"],"crypto.Hash.prototype[[Prototype]]1":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"crypto.Hash.prototype[[Prototype]]2":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"crypto.Hash.prototype[[Prototype]]3":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"crypto.Hash.prototype[[Prototype]]4":["constructor:f","eventNames:f","pipe:f"],"crypto.Hash.prototype[[Prototype]]5":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"crypto.Hmac[[Function]]":["length:n","name:s","prototype:o"],"crypto.Hmac.prototype":["_flush:f","_transform:f","constructor:f","digest:f","update:f"],"crypto.Hmac.prototype[[Prototype]]0":["_readableState:a","_writableState:a","constructor:f"],"crypto.Hmac.prototype[[Prototype]]1":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"crypto.Hmac.prototype[[Prototype]]2":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"crypto.Hmac.prototype[[Prototype]]3":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"crypto.Hmac.prototype[[Prototype]]4":["constructor:f","eventNames:f","pipe:f"],"crypto.Hmac.prototype[[Prototype]]5":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"crypto.KeyObject[[Function]]":["from:f","length:n","name:s","prototype:o"],"crypto.KeyObject.prototype":["@@Symbol.toStringTag:s","constructor:f","equals:f","toCryptoKey:f","type:a"],"crypto.KeyObject.prototype[[Prototype]]0":["constructor:f"],"crypto.Sign[[Function]]":["length:n","name:s","prototype:o"],"crypto.Sign.prototype":["_write:f","constructor:f","sign:f","update:f"],"crypto.Sign.prototype[[Prototype]]0":["@@Symbol.asyncDispose:f","@@nodejs.rejection:f","_destroy:f","_undestroy:f","_write:f","_writev:l","closed:a","constructor:f","cork:f","destroy:f","destroyed:a","end:f","errored:a","pipe:f","setDefaultEncoding:f","uncork:f","writable:a","writableAborted:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"crypto.Sign.prototype[[Prototype]]1":["constructor:f","eventNames:f","pipe:f"],"crypto.Sign.prototype[[Prototype]]2":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"crypto.Verify[[Function]]":["length:n","name:s","prototype:o"],"crypto.Verify.prototype":["_write:f","constructor:f","update:f","verify:f"],"crypto.Verify.prototype[[Prototype]]0":["@@Symbol.asyncDispose:f","@@nodejs.rejection:f","_destroy:f","_undestroy:f","_write:f","_writev:l","closed:a","constructor:f","cork:f","destroy:f","destroyed:a","end:f","errored:a","pipe:f","setDefaultEncoding:f","uncork:f","writable:a","writableAborted:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"crypto.Verify.prototype[[Prototype]]1":["constructor:f","eventNames:f","pipe:f"],"crypto.Verify.prototype[[Prototype]]2":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"crypto.X509Certificate[[Function]]":["length:n","name:s","prototype:o"],"crypto.X509Certificate.prototype":["@@messaging_clone_symbol:f","@@messaging_deserialize_symbol:f","@@nodejs.util.inspect.custom:f","ca:a","checkEmail:f","checkHost:f","checkIP:f","checkIssued:f","checkPrivateKey:f","constructor:f","fingerprint256:a","fingerprint512:a","fingerprint:a","infoAccess:a","issuer:a","issuerCertificate:a","keyUsage:a","publicKey:a","raw:a","serialNumber:a","signatureAlgorithm:a","signatureAlgorithmOid:a","subject:a","subjectAltName:a","toJSON:f","toLegacyObject:f","toString:f","validFrom:a","validFromDate:a","validTo:a","validToDate:a","verify:f"],"crypto.secureHeapUsed[[Function]]":["length:n","name:s"],"crypto.constants":["defaultCipherList:s","defaultCoreCipherList:s"]},"dgram":{"dgram.createSocket[[Function]]":["length:n","name:s","prototype:o"],"dgram.createSocket.prototype":["constructor:f"],"dgram.Socket[[Function]]":["length:n","name:s","prototype:o"],"dgram.Socket.prototype":["constructor:f"]},"dns":{"dns.lookup[[Function]]":["length:n","name:s","prototype:o"],"dns.lookup.prototype":["constructor:f"],"dns.lookupService[[Function]]":["length:n","name:s","prototype:o"],"dns.lookupService.prototype":["constructor:f"],"dns.Resolver[[Function]]":["length:n","name:s","prototype:o"],"dns.Resolver.prototype":["constructor:f"],"dns.getDefaultResultOrder[[Function]]":["length:n","name:s","prototype:o"],"dns.getDefaultResultOrder.prototype":["constructor:f"],"dns.setDefaultResultOrder[[Function]]":["length:n","name:s","prototype:o"],"dns.setDefaultResultOrder.prototype":["constructor:f"],"dns.setServers[[Function]]":["length:n","name:s","prototype:o"],"dns.setServers.prototype":["constructor:f"],"dns.getServers[[Function]]":["length:n","name:s","prototype:o"],"dns.getServers.prototype":["constructor:f"],"dns.resolve[[Function]]":["length:n","name:s","prototype:o"],"dns.resolve.prototype":["constructor:f"],"dns.resolve4[[Function]]":["length:n","name:s","prototype:o"],"dns.resolve4.prototype":["constructor:f"],"dns.resolve6[[Function]]":["length:n","name:s","prototype:o"],"dns.resolve6.prototype":["constructor:f"],"dns.resolveAny[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveAny.prototype":["constructor:f"],"dns.resolveCaa[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveCaa.prototype":["constructor:f"],"dns.resolveCname[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveCname.prototype":["constructor:f"],"dns.resolveMx[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveMx.prototype":["constructor:f"],"dns.resolveNaptr[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveNaptr.prototype":["constructor:f"],"dns.resolveNs[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveNs.prototype":["constructor:f"],"dns.resolvePtr[[Function]]":["length:n","name:s","prototype:o"],"dns.resolvePtr.prototype":["constructor:f"],"dns.resolveSoa[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveSoa.prototype":["constructor:f"],"dns.resolveSrv[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveSrv.prototype":["constructor:f"],"dns.resolveTlsa[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveTlsa.prototype":["constructor:f"],"dns.resolveTxt[[Function]]":["length:n","name:s","prototype:o"],"dns.resolveTxt.prototype":["constructor:f"],"dns.reverse[[Function]]":["length:n","name:s","prototype:o"],"dns.reverse.prototype":["constructor:f"],"dns.promises[[Function]]":["length:n","name:s","prototype:o"],"dns.promises.prototype":["constructor:f"]},"dns/promises":{"dns/promises.lookup[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.lookup.prototype":["constructor:f"],"dns/promises.lookupService[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.lookupService.prototype":["constructor:f"],"dns/promises.Resolver[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.Resolver.prototype":["constructor:f"],"dns/promises.getDefaultResultOrder[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.getDefaultResultOrder.prototype":["constructor:f"],"dns/promises.setDefaultResultOrder[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.setDefaultResultOrder.prototype":["constructor:f"],"dns/promises.setServers[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.setServers.prototype":["constructor:f"],"dns/promises.getServers[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.getServers.prototype":["constructor:f"],"dns/promises.resolve[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolve.prototype":["constructor:f"],"dns/promises.resolve4[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolve4.prototype":["constructor:f"],"dns/promises.resolve6[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolve6.prototype":["constructor:f"],"dns/promises.resolveAny[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveAny.prototype":["constructor:f"],"dns/promises.resolveCaa[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveCaa.prototype":["constructor:f"],"dns/promises.resolveCname[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveCname.prototype":["constructor:f"],"dns/promises.resolveMx[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveMx.prototype":["constructor:f"],"dns/promises.resolveNaptr[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveNaptr.prototype":["constructor:f"],"dns/promises.resolveNs[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveNs.prototype":["constructor:f"],"dns/promises.resolvePtr[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolvePtr.prototype":["constructor:f"],"dns/promises.resolveSoa[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveSoa.prototype":["constructor:f"],"dns/promises.resolveSrv[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveSrv.prototype":["constructor:f"],"dns/promises.resolveTlsa[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveTlsa.prototype":["constructor:f"],"dns/promises.resolveTxt[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.resolveTxt.prototype":["constructor:f"],"dns/promises.reverse[[Function]]":["length:n","name:s","prototype:o"],"dns/promises.reverse.prototype":["constructor:f"]},"domain":{"domain.Domain[[Function]]":["length:n","name:s","prototype:o"],"domain.Domain.prototype":["_errorHandler:f","add:f","bind:f","constructor:f","enter:f","exit:f","intercept:f","members:u","remove:f","run:f"],"domain.Domain.prototype[[Prototype]]0":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"domain.createDomain[[Function]]":["length:n","name:s","prototype:o"],"domain.createDomain.prototype":["constructor:f"],"domain.create[[Function]]":["length:n","name:s","prototype:o"],"domain.create.prototype":["constructor:f"]},"events":{"events.prototype":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"events.addAbortListener[[Function]]":["length:n","name:s","prototype:o"],"events.addAbortListener.prototype":["constructor:f"],"events.once[[Function]]":["length:n","name:s"],"events.on[[Function]]":["length:n","name:s","prototype:o"],"events.on.prototype":["constructor:f"],"events.getEventListeners[[Function]]":["length:n","name:s","prototype:o"],"events.getEventListeners.prototype":["constructor:f"],"events.getMaxListeners[[Function]]":["length:n","name:s","prototype:o"],"events.getMaxListeners.prototype":["constructor:f"],"events.listenerCount[[Function]]":["length:n","name:s","prototype:o"],"events.listenerCount.prototype":["constructor:f"],"events.EventEmitter[[Function]]":["EventEmitter:f","EventEmitterAsyncResource:a","addAbortListener:f","captureRejectionSymbol:y","captureRejections:a","defaultMaxListeners:a","errorMonitor:y","getEventListeners:f","getMaxListeners:f","init:f","kMaxEventTargetListeners:y","kMaxEventTargetListenersWarned:y","length:n","listenerCount:f","name:s","on:f","once:f","prototype:o","setMaxListeners:f","usingDomains:b"],"events.EventEmitter.prototype":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"events.setMaxListeners[[Function]]":["length:n","name:s","prototype:o"],"events.setMaxListeners.prototype":["constructor:f"],"events.init[[Function]]":["length:n","name:s","prototype:o"],"events.init.prototype":["constructor:f"]},"fs":{"fs.appendFile[[Function]]":["length:n","name:s","prototype:o"],"fs.appendFile.prototype":["constructor:f"],"fs.appendFileSync[[Function]]":["length:n","name:s","prototype:o"],"fs.appendFileSync.prototype":["constructor:f"],"fs.access[[Function]]":["length:n","name:s","prototype:o"],"fs.access.prototype":["constructor:f"],"fs.accessSync[[Function]]":["length:n","name:s","prototype:o"],"fs.accessSync.prototype":["constructor:f"],"fs.chown[[Function]]":["length:n","name:s","prototype:o"],"fs.chown.prototype":["constructor:f"],"fs.chownSync[[Function]]":["length:n","name:s","prototype:o"],"fs.chownSync.prototype":["constructor:f"],"fs.chmod[[Function]]":["length:n","name:s","prototype:o"],"fs.chmod.prototype":["constructor:f"],"fs.chmodSync[[Function]]":["length:n","name:s","prototype:o"],"fs.chmodSync.prototype":["constructor:f"],"fs.close[[Function]]":["length:n","name:s","prototype:o"],"fs.close.prototype":["constructor:f"],"fs.closeSync[[Function]]":["length:n","name:s","prototype:o"],"fs.closeSync.prototype":["constructor:f"],"fs.copyFile[[Function]]":["length:n","name:s","prototype:o"],"fs.copyFile.prototype":["constructor:f"],"fs.copyFileSync[[Function]]":["length:n","name:s","prototype:o"],"fs.copyFileSync.prototype":["constructor:f"],"fs.cp[[Function]]":["length:n","name:s","prototype:o"],"fs.cp.prototype":["constructor:f"],"fs.cpSync[[Function]]":["length:n","name:s","prototype:o"],"fs.cpSync.prototype":["constructor:f"],"fs.createReadStream[[Function]]":["length:n","name:s","prototype:o"],"fs.createReadStream.prototype":["constructor:f"],"fs.createWriteStream[[Function]]":["length:n","name:s","prototype:o"],"fs.createWriteStream.prototype":["constructor:f"],"fs.exists[[Function]]":["length:n","name:s","prototype:o"],"fs.exists.prototype":["constructor:f"],"fs.existsSync[[Function]]":["length:n","name:s","prototype:o"],"fs.existsSync.prototype":["constructor:f"],"fs.fchown[[Function]]":["length:n","name:s","prototype:o"],"fs.fchown.prototype":["constructor:f"],"fs.fchownSync[[Function]]":["length:n","name:s","prototype:o"],"fs.fchownSync.prototype":["constructor:f"],"fs.fchmod[[Function]]":["length:n","name:s","prototype:o"],"fs.fchmod.prototype":["constructor:f"],"fs.fchmodSync[[Function]]":["length:n","name:s","prototype:o"],"fs.fchmodSync.prototype":["constructor:f"],"fs.fdatasync[[Function]]":["length:n","name:s","prototype:o"],"fs.fdatasync.prototype":["constructor:f"],"fs.fdatasyncSync[[Function]]":["length:n","name:s","prototype:o"],"fs.fdatasyncSync.prototype":["constructor:f"],"fs.fstat[[Function]]":["length:n","name:s","prototype:o"],"fs.fstat.prototype":["constructor:f"],"fs.fstatSync[[Function]]":["length:n","name:s","prototype:o"],"fs.fstatSync.prototype":["constructor:f"],"fs.fsync[[Function]]":["length:n","name:s","prototype:o"],"fs.fsync.prototype":["constructor:f"],"fs.fsyncSync[[Function]]":["length:n","name:s","prototype:o"],"fs.fsyncSync.prototype":["constructor:f"],"fs.ftruncate[[Function]]":["length:n","name:s","prototype:o"],"fs.ftruncate.prototype":["constructor:f"],"fs.ftruncateSync[[Function]]":["length:n","name:s","prototype:o"],"fs.ftruncateSync.prototype":["constructor:f"],"fs.futimes[[Function]]":["length:n","name:s","prototype:o"],"fs.futimes.prototype":["constructor:f"],"fs.futimesSync[[Function]]":["length:n","name:s","prototype:o"],"fs.futimesSync.prototype":["constructor:f"],"fs.glob[[Function]]":["length:n","name:s","prototype:o"],"fs.glob.prototype":["constructor:f"],"fs.globSync[[Function]]":["length:n","name:s","prototype:o"],"fs.globSync.prototype":["constructor:f"],"fs.lchown[[Function]]":["length:n","name:s","prototype:o"],"fs.lchown.prototype":["constructor:f"],"fs.lchownSync[[Function]]":["length:n","name:s","prototype:o"],"fs.lchownSync.prototype":["constructor:f"],"fs.link[[Function]]":["length:n","name:s","prototype:o"],"fs.link.prototype":["constructor:f"],"fs.linkSync[[Function]]":["length:n","name:s","prototype:o"],"fs.linkSync.prototype":["constructor:f"],"fs.lstat[[Function]]":["length:n","name:s","prototype:o"],"fs.lstat.prototype":["constructor:f"],"fs.lstatSync[[Function]]":["length:n","name:s","prototype:o"],"fs.lstatSync.prototype":["constructor:f"],"fs.lutimes[[Function]]":["length:n","name:s","prototype:o"],"fs.lutimes.prototype":["constructor:f"],"fs.lutimesSync[[Function]]":["length:n","name:s","prototype:o"],"fs.lutimesSync.prototype":["constructor:f"],"fs.mkdir[[Function]]":["length:n","name:s","prototype:o"],"fs.mkdir.prototype":["constructor:f"],"fs.mkdirSync[[Function]]":["length:n","name:s","prototype:o"],"fs.mkdirSync.prototype":["constructor:f"],"fs.mkdtemp[[Function]]":["length:n","name:s","prototype:o"],"fs.mkdtemp.prototype":["constructor:f"],"fs.mkdtempSync[[Function]]":["length:n","name:s","prototype:o"],"fs.mkdtempSync.prototype":["constructor:f"],"fs.mkdtempDisposableSync[[Function]]":["length:n","name:s","prototype:o"],"fs.mkdtempDisposableSync.prototype":["constructor:f"],"fs.open[[Function]]":["length:n","name:s","prototype:o"],"fs.open.prototype":["constructor:f"],"fs.openSync[[Function]]":["length:n","name:s","prototype:o"],"fs.openSync.prototype":["constructor:f"],"fs.openAsBlob[[Function]]":["length:n","name:s","prototype:o"],"fs.openAsBlob.prototype":["constructor:f"],"fs.readdir[[Function]]":["length:n","name:s","prototype:o"],"fs.readdir.prototype":["constructor:f"],"fs.readdirSync[[Function]]":["length:n","name:s","prototype:o"],"fs.readdirSync.prototype":["constructor:f"],"fs.read[[Function]]":["length:n","name:s","prototype:o"],"fs.read.prototype":["constructor:f"],"fs.readSync[[Function]]":["length:n","name:s","prototype:o"],"fs.readSync.prototype":["constructor:f"],"fs.readv[[Function]]":["length:n","name:s","prototype:o"],"fs.readv.prototype":["constructor:f"],"fs.readvSync[[Function]]":["length:n","name:s","prototype:o"],"fs.readvSync.prototype":["constructor:f"],"fs.readFile[[Function]]":["length:n","name:s","prototype:o"],"fs.readFile.prototype":["constructor:f"],"fs.readFileSync[[Function]]":["length:n","name:s","prototype:o"],"fs.readFileSync.prototype":["constructor:f"],"fs.readlink[[Function]]":["length:n","name:s","prototype:o"],"fs.readlink.prototype":["constructor:f"],"fs.readlinkSync[[Function]]":["length:n","name:s","prototype:o"],"fs.readlinkSync.prototype":["constructor:f"],"fs.realpath[[Function]]":["length:n","name:s","prototype:o"],"fs.realpath.prototype":["constructor:f"],"fs.realpathSync[[Function]]":["length:n","name:s","prototype:o"],"fs.realpathSync.prototype":["constructor:f"],"fs.rename[[Function]]":["length:n","name:s","prototype:o"],"fs.rename.prototype":["constructor:f"],"fs.renameSync[[Function]]":["length:n","name:s","prototype:o"],"fs.renameSync.prototype":["constructor:f"],"fs.rm[[Function]]":["length:n","name:s","prototype:o"],"fs.rm.prototype":["constructor:f"],"fs.rmSync[[Function]]":["length:n","name:s","prototype:o"],"fs.rmSync.prototype":["constructor:f"],"fs.rmdir[[Function]]":["length:n","name:s","prototype:o"],"fs.rmdir.prototype":["constructor:f"],"fs.rmdirSync[[Function]]":["length:n","name:s","prototype:o"],"fs.rmdirSync.prototype":["constructor:f"],"fs.stat[[Function]]":["length:n","name:s","prototype:o"],"fs.stat.prototype":["constructor:f"],"fs.statfs[[Function]]":["length:n","name:s","prototype:o"],"fs.statfs.prototype":["constructor:f"],"fs.statSync[[Function]]":["length:n","name:s","prototype:o"],"fs.statSync.prototype":["constructor:f"],"fs.statfsSync[[Function]]":["length:n","name:s","prototype:o"],"fs.statfsSync.prototype":["constructor:f"],"fs.symlink[[Function]]":["length:n","name:s","prototype:o"],"fs.symlink.prototype":["constructor:f"],"fs.symlinkSync[[Function]]":["length:n","name:s","prototype:o"],"fs.symlinkSync.prototype":["constructor:f"],"fs.truncate[[Function]]":["length:n","name:s","prototype:o"],"fs.truncate.prototype":["constructor:f"],"fs.truncateSync[[Function]]":["length:n","name:s","prototype:o"],"fs.truncateSync.prototype":["constructor:f"],"fs.unwatchFile[[Function]]":["length:n","name:s","prototype:o"],"fs.unwatchFile.prototype":["constructor:f"],"fs.unlink[[Function]]":["length:n","name:s","prototype:o"],"fs.unlink.prototype":["constructor:f"],"fs.unlinkSync[[Function]]":["length:n","name:s","prototype:o"],"fs.unlinkSync.prototype":["constructor:f"],"fs.utimes[[Function]]":["length:n","name:s","prototype:o"],"fs.utimes.prototype":["constructor:f"],"fs.utimesSync[[Function]]":["length:n","name:s","prototype:o"],"fs.utimesSync.prototype":["constructor:f"],"fs.watch[[Function]]":["length:n","name:s","prototype:o"],"fs.watch.prototype":["constructor:f"],"fs.watchFile[[Function]]":["length:n","name:s","prototype:o"],"fs.watchFile.prototype":["constructor:f"],"fs.writeFile[[Function]]":["length:n","name:s","prototype:o"],"fs.writeFile.prototype":["constructor:f"],"fs.writeFileSync[[Function]]":["length:n","name:s","prototype:o"],"fs.writeFileSync.prototype":["constructor:f"],"fs.write[[Function]]":["length:n","name:s","prototype:o"],"fs.write.prototype":["constructor:f"],"fs.writeSync[[Function]]":["length:n","name:s","prototype:o"],"fs.writeSync.prototype":["constructor:f"],"fs.writev[[Function]]":["length:n","name:s","prototype:o"],"fs.writev.prototype":["constructor:f"],"fs.writevSync[[Function]]":["length:n","name:s","prototype:o"],"fs.writevSync.prototype":["constructor:f"],"fs.Dirent[[Function]]":["length:n","name:s","prototype:o"],"fs.Dirent.prototype":["constructor:f"],"fs.Stats[[Function]]":["length:n","name:s","prototype:o"],"fs.Stats.prototype":["constructor:f"],"fs.ReadStream[[Function]]":["length:n","name:s","prototype:o"],"fs.ReadStream.prototype":["constructor:f"],"fs.WriteStream[[Function]]":["length:n","name:s","prototype:o"],"fs.WriteStream.prototype":["constructor:f"],"fs.FileReadStream[[Function]]":["length:n","name:s","prototype:o"],"fs.FileReadStream.prototype":["constructor:f"],"fs.FileWriteStream[[Function]]":["length:n","name:s","prototype:o"],"fs.FileWriteStream.prototype":["constructor:f"],"fs.Utf8Stream[[Function]]":["length:n","name:s","prototype:o"],"fs.Utf8Stream.prototype":["constructor:f"],"fs._toUnixTimestamp[[Function]]":["length:n","name:s","prototype:o"],"fs._toUnixTimestamp.prototype":["constructor:f"],"fs.Dir[[Function]]":["length:n","name:s","prototype:o"],"fs.Dir.prototype":["constructor:f"],"fs.opendir[[Function]]":["length:n","name:s","prototype:o"],"fs.opendir.prototype":["constructor:f"],"fs.opendirSync[[Function]]":["length:n","name:s","prototype:o"],"fs.opendirSync.prototype":["constructor:f"],"fs.constants":[],"fs.promises[[Function]]":["length:n","name:s","prototype:o"],"fs.promises.prototype":["constructor:f"]},"fs/promises":{"fs/promises.access[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.access.prototype":["constructor:f"],"fs/promises.copyFile[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.copyFile.prototype":["constructor:f"],"fs/promises.cp[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.cp.prototype":["constructor:f"],"fs/promises.glob[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.glob.prototype":["constructor:f"],"fs/promises.open[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.open.prototype":["constructor:f"],"fs/promises.opendir[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.opendir.prototype":["constructor:f"],"fs/promises.rename[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.rename.prototype":["constructor:f"],"fs/promises.truncate[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.truncate.prototype":["constructor:f"],"fs/promises.rm[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.rm.prototype":["constructor:f"],"fs/promises.rmdir[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.rmdir.prototype":["constructor:f"],"fs/promises.mkdir[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.mkdir.prototype":["constructor:f"],"fs/promises.readdir[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.readdir.prototype":["constructor:f"],"fs/promises.readlink[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.readlink.prototype":["constructor:f"],"fs/promises.symlink[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.symlink.prototype":["constructor:f"],"fs/promises.lstat[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.lstat.prototype":["constructor:f"],"fs/promises.stat[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.stat.prototype":["constructor:f"],"fs/promises.statfs[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.statfs.prototype":["constructor:f"],"fs/promises.link[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.link.prototype":["constructor:f"],"fs/promises.unlink[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.unlink.prototype":["constructor:f"],"fs/promises.chmod[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.chmod.prototype":["constructor:f"],"fs/promises.lchmod[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.lchmod.prototype":["constructor:f"],"fs/promises.lchown[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.lchown.prototype":["constructor:f"],"fs/promises.chown[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.chown.prototype":["constructor:f"],"fs/promises.utimes[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.utimes.prototype":["constructor:f"],"fs/promises.lutimes[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.lutimes.prototype":["constructor:f"],"fs/promises.realpath[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.realpath.prototype":["constructor:f"],"fs/promises.mkdtemp[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.mkdtemp.prototype":["constructor:f"],"fs/promises.mkdtempDisposable[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.mkdtempDisposable.prototype":["constructor:f"],"fs/promises.writeFile[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.writeFile.prototype":["constructor:f"],"fs/promises.appendFile[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.appendFile.prototype":["constructor:f"],"fs/promises.readFile[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.readFile.prototype":["constructor:f"],"fs/promises.watch[[Function]]":["length:n","name:s","prototype:o"],"fs/promises.watch.prototype":["constructor:f"],"fs/promises.constants":[]},"http":{"http._connectionListener[[Function]]":["length:n","name:s","prototype:o"],"http._connectionListener.prototype":["constructor:f"],"http.STATUS_CODES":["100:s","101:s","102:s","103:s","200:s","201:s","202:s","203:s","204:s","205:s","206:s","207:s","208:s","226:s","300:s","301:s","302:s","303:s","304:s","305:s","307:s","308:s","400:s","401:s","402:s","403:s","404:s","405:s","406:s","407:s","408:s","409:s","410:s","411:s","412:s","413:s","414:s","415:s","416:s","417:s","418:s","421:s","422:s","423:s","424:s","425:s","426:s","428:s","429:s","431:s","451:s","500:s","501:s","502:s","503:s","504:s","505:s","506:s","507:s","508:s","509:s","510:s","511:s"],"http.Agent[[Function]]":["length:n","name:s","prototype:o"],"http.Agent.prototype":["constructor:f"],"http.ClientRequest[[Function]]":["length:n","name:s","prototype:o"],"http.ClientRequest.prototype":["constructor:f"],"http.IncomingMessage[[Function]]":["length:n","name:s","prototype:o"],"http.IncomingMessage.prototype":["constructor:f"],"http.OutgoingMessage[[Function]]":["length:n","name:s","prototype:o"],"http.OutgoingMessage.prototype":["constructor:f"],"http.Server[[Function]]":["length:n","name:s","prototype:o"],"http.Server.prototype":["constructor:f"],"http.ServerResponse[[Function]]":["length:n","name:s","prototype:o"],"http.ServerResponse.prototype":["constructor:f"],"http.createServer[[Function]]":["length:n","name:s","prototype:o"],"http.createServer.prototype":["constructor:f"],"http.validateHeaderName[[Function]]":["length:n","name:s","prototype:o"],"http.validateHeaderName.prototype":["constructor:f"],"http.validateHeaderValue[[Function]]":["length:n","name:s","prototype:o"],"http.validateHeaderValue.prototype":["constructor:f"],"http.get[[Function]]":["length:n","name:s","prototype:o"],"http.get.prototype":["constructor:f"],"http.request[[Function]]":["length:n","name:s","prototype:o"],"http.request.prototype":["constructor:f"],"http.setMaxIdleHTTPParsers[[Function]]":["length:n","name:s","prototype:o"],"http.setMaxIdleHTTPParsers.prototype":["constructor:f"],"http.setGlobalProxyFromEnv[[Function]]":["length:n","name:s","prototype:o"],"http.setGlobalProxyFromEnv.prototype":["constructor:f"],"http.maxHeaderSize[[Function]]":["length:n","name:s","prototype:o"],"http.maxHeaderSize.prototype":["constructor:f"],"http.globalAgent[[Function]]":["length:n","name:s","prototype:o"],"http.globalAgent.prototype":["constructor:f"],"http.WebSocket[[Function]]":["length:n","name:s","prototype:o"],"http.WebSocket.prototype":["constructor:f"],"http.CloseEvent[[Function]]":["length:n","name:s","prototype:o"],"http.CloseEvent.prototype":["constructor:f"],"http.MessageEvent[[Function]]":["length:n","name:s","prototype:o"],"http.MessageEvent.prototype":["constructor:f"]},"http2":{"http2.connect[[Function]]":["length:n","name:s","prototype:o"],"http2.connect.prototype":["constructor:f"],"http2.constants":["HTTP2_HEADER_ACCEPT:s","HTTP2_HEADER_ACCEPT_CHARSET:s","HTTP2_HEADER_ACCEPT_ENCODING:s","HTTP2_HEADER_ACCEPT_LANGUAGE:s","HTTP2_HEADER_ACCEPT_RANGES:s","HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS:s","HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS:s","HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS:s","HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN:s","HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS:s","HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE:s","HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS:s","HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD:s","HTTP2_HEADER_AGE:s","HTTP2_HEADER_ALLOW:s","HTTP2_HEADER_ALT_SVC:s","HTTP2_HEADER_AUTHORITY:s","HTTP2_HEADER_AUTHORIZATION:s","HTTP2_HEADER_CACHE_CONTROL:s","HTTP2_HEADER_CONNECTION:s","HTTP2_HEADER_CONTENT_DISPOSITION:s","HTTP2_HEADER_CONTENT_ENCODING:s","HTTP2_HEADER_CONTENT_LANGUAGE:s","HTTP2_HEADER_CONTENT_LENGTH:s","HTTP2_HEADER_CONTENT_LOCATION:s","HTTP2_HEADER_CONTENT_MD5:s","HTTP2_HEADER_CONTENT_RANGE:s","HTTP2_HEADER_CONTENT_SECURITY_POLICY:s","HTTP2_HEADER_CONTENT_TYPE:s","HTTP2_HEADER_COOKIE:s","HTTP2_HEADER_DATE:s","HTTP2_HEADER_DNT:s","HTTP2_HEADER_EARLY_DATA:s","HTTP2_HEADER_ETAG:s","HTTP2_HEADER_EXPECT:s","HTTP2_HEADER_EXPECT_CT:s","HTTP2_HEADER_EXPIRES:s","HTTP2_HEADER_FORWARDED:s","HTTP2_HEADER_FROM:s","HTTP2_HEADER_HOST:s","HTTP2_HEADER_HTTP2_SETTINGS:s","HTTP2_HEADER_IF_MATCH:s","HTTP2_HEADER_IF_MODIFIED_SINCE:s","HTTP2_HEADER_IF_NONE_MATCH:s","HTTP2_HEADER_IF_RANGE:s","HTTP2_HEADER_IF_UNMODIFIED_SINCE:s","HTTP2_HEADER_KEEP_ALIVE:s","HTTP2_HEADER_LAST_MODIFIED:s","HTTP2_HEADER_LINK:s","HTTP2_HEADER_LOCATION:s","HTTP2_HEADER_MAX_FORWARDS:s","HTTP2_HEADER_METHOD:s","HTTP2_HEADER_ORIGIN:s","HTTP2_HEADER_PATH:s","HTTP2_HEADER_PREFER:s","HTTP2_HEADER_PRIORITY:s","HTTP2_HEADER_PROTOCOL:s","HTTP2_HEADER_PROXY_AUTHENTICATE:s","HTTP2_HEADER_PROXY_AUTHORIZATION:s","HTTP2_HEADER_PROXY_CONNECTION:s","HTTP2_HEADER_PURPOSE:s","HTTP2_HEADER_RANGE:s","HTTP2_HEADER_REFERER:s","HTTP2_HEADER_REFRESH:s","HTTP2_HEADER_RETRY_AFTER:s","HTTP2_HEADER_SCHEME:s","HTTP2_HEADER_SERVER:s","HTTP2_HEADER_SET_COOKIE:s","HTTP2_HEADER_STATUS:s","HTTP2_HEADER_STRICT_TRANSPORT_SECURITY:s","HTTP2_HEADER_TE:s","HTTP2_HEADER_TIMING_ALLOW_ORIGIN:s","HTTP2_HEADER_TK:s","HTTP2_HEADER_TRAILER:s","HTTP2_HEADER_TRANSFER_ENCODING:s","HTTP2_HEADER_UPGRADE:s","HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS:s","HTTP2_HEADER_USER_AGENT:s","HTTP2_HEADER_VARY:s","HTTP2_HEADER_VIA:s","HTTP2_HEADER_WARNING:s","HTTP2_HEADER_WWW_AUTHENTICATE:s","HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS:s","HTTP2_HEADER_X_FORWARDED_FOR:s","HTTP2_HEADER_X_FRAME_OPTIONS:s","HTTP2_HEADER_X_XSS_PROTECTION:s","HTTP2_METHOD_ACL:s","HTTP2_METHOD_BASELINE_CONTROL:s","HTTP2_METHOD_BIND:s","HTTP2_METHOD_CHECKIN:s","HTTP2_METHOD_CHECKOUT:s","HTTP2_METHOD_CONNECT:s","HTTP2_METHOD_COPY:s","HTTP2_METHOD_DELETE:s","HTTP2_METHOD_GET:s","HTTP2_METHOD_HEAD:s","HTTP2_METHOD_LABEL:s","HTTP2_METHOD_LINK:s","HTTP2_METHOD_LOCK:s","HTTP2_METHOD_MERGE:s","HTTP2_METHOD_MKACTIVITY:s","HTTP2_METHOD_MKCALENDAR:s","HTTP2_METHOD_MKCOL:s","HTTP2_METHOD_MKREDIRECTREF:s","HTTP2_METHOD_MKWORKSPACE:s","HTTP2_METHOD_MOVE:s","HTTP2_METHOD_OPTIONS:s","HTTP2_METHOD_ORDERPATCH:s","HTTP2_METHOD_PATCH:s","HTTP2_METHOD_POST:s","HTTP2_METHOD_PRI:s","HTTP2_METHOD_PROPFIND:s","HTTP2_METHOD_PROPPATCH:s","HTTP2_METHOD_PUT:s","HTTP2_METHOD_REBIND:s","HTTP2_METHOD_REPORT:s","HTTP2_METHOD_SEARCH:s","HTTP2_METHOD_TRACE:s","HTTP2_METHOD_UNBIND:s","HTTP2_METHOD_UNCHECKOUT:s","HTTP2_METHOD_UNLINK:s","HTTP2_METHOD_UNLOCK:s","HTTP2_METHOD_UPDATE:s","HTTP2_METHOD_UPDATEREDIRECTREF:s","HTTP2_METHOD_VERSION_CONTROL:s"],"http2.createServer[[Function]]":["length:n","name:s","prototype:o"],"http2.createServer.prototype":["constructor:f"],"http2.createSecureServer[[Function]]":["length:n","name:s","prototype:o"],"http2.createSecureServer.prototype":["constructor:f"],"http2.getDefaultSettings[[Function]]":["length:n","name:s","prototype:o"],"http2.getDefaultSettings.prototype":["constructor:f"],"http2.getPackedSettings[[Function]]":["length:n","name:s","prototype:o"],"http2.getPackedSettings.prototype":["constructor:f"],"http2.getUnpackedSettings[[Function]]":["length:n","name:s","prototype:o"],"http2.getUnpackedSettings.prototype":["constructor:f"],"http2.performServerHandshake[[Function]]":["length:n","name:s","prototype:o"],"http2.performServerHandshake.prototype":["constructor:f"],"http2.Http2ServerRequest[[Function]]":["length:n","name:s","prototype:o"],"http2.Http2ServerRequest.prototype":["constructor:f"],"http2.Http2ServerResponse[[Function]]":["length:n","name:s","prototype:o"],"http2.Http2ServerResponse.prototype":["constructor:f"]},"https":{"https.Agent[[Function]]":["length:n","name:s","prototype:o"],"https.Agent.prototype":["constructor:f"],"https.globalAgent":["@@kCapture:b","@@shapeMode:b","_events:o","_eventsCount:n","_maxListeners:u","_sessionCache:o","agentKeepAliveTimeoutBuffer:n","defaultPort:n","freeSockets:o","keepAlive:b","keepAliveMsecs:n","maxCachedSessions:n","maxFreeSockets:n","maxSockets:n","maxTotalSockets:n","options:o","protocol:s","requests:o","scheduling:s","sockets:o","totalSocketCount:n"],"https.globalAgent[[Prototype]]0":["_cacheSession:f","_evictSession:f","_getSession:f","constructor:f","createConnection:f","getName:f","keepSocketAlive:f"],"https.globalAgent[[Prototype]]1":["addRequest:f","constructor:f","createConnection:f","createSocket:f","destroy:f","getName:f","keepSocketAlive:f","removeSocket:f","reuseSocket:f"],"https.globalAgent[[Prototype]]2":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"https.Server[[Function]]":["length:n","name:s","prototype:o"],"https.Server.prototype":["constructor:f"],"https.createServer[[Function]]":["length:n","name:s","prototype:o"],"https.createServer.prototype":["constructor:f"],"https.get[[Function]]":["length:n","name:s","prototype:o"],"https.get.prototype":["constructor:f"],"https.request[[Function]]":["length:n","name:s","prototype:o"],"https.request.prototype":["constructor:f"]},"inspector":{"inspector.open[[Function]]":["length:n","name:s","prototype:o"],"inspector.open.prototype":["constructor:f"],"inspector.close[[Function]]":["length:n","name:s","prototype:o"],"inspector.close.prototype":["constructor:f"],"inspector.url[[Function]]":["length:n","name:s","prototype:o"],"inspector.url.prototype":["constructor:f"],"inspector.waitForDebugger[[Function]]":["length:n","name:s","prototype:o"],"inspector.waitForDebugger.prototype":["constructor:f"],"inspector.console":["@@Symbol.toStringTag:s","assert:f","clear:f","context:f","count:f","countReset:f","debug:f","dir:f","dirxml:f","error:f","group:f","groupCollapsed:f","groupEnd:f","info:f","log:f","profile:f","profileEnd:f","table:f","time:f","timeEnd:f","timeLog:f","timeStamp:f","trace:f","warn:f"],"inspector.console[[Prototype]]0":[],"inspector.Session[[Function]]":["length:n","name:s","prototype:o"],"inspector.Session.prototype":["constructor:f"],"inspector.Network":["dataReceived:f","dataSent:f","loadingFailed:f","loadingFinished:f","requestWillBeSent:f","responseReceived:f","webSocketClosed:f","webSocketCreated:f","webSocketHandshakeResponseReceived:f"],"inspector.NetworkResources":["put:f"],"inspector.DOMStorage":["domStorageItemAdded:f","domStorageItemRemoved:f","domStorageItemUpdated:f","domStorageItemsCleared:f","registerStorage:f"]},"inspector/promises":{"inspector/promises.open[[Function]]":["length:n","name:s","prototype:o"],"inspector/promises.open.prototype":["constructor:f"],"inspector/promises.close[[Function]]":["length:n","name:s","prototype:o"],"inspector/promises.close.prototype":["constructor:f"],"inspector/promises.url[[Function]]":["length:n","name:s","prototype:o"],"inspector/promises.url.prototype":["constructor:f"],"inspector/promises.waitForDebugger[[Function]]":["length:n","name:s","prototype:o"],"inspector/promises.waitForDebugger.prototype":["constructor:f"],"inspector/promises.console":["@@Symbol.toStringTag:s","assert:f","clear:f","context:f","count:f","countReset:f","debug:f","dir:f","dirxml:f","error:f","group:f","groupCollapsed:f","groupEnd:f","info:f","log:f","profile:f","profileEnd:f","table:f","time:f","timeEnd:f","timeLog:f","timeStamp:f","trace:f","warn:f"],"inspector/promises.console[[Prototype]]0":[],"inspector/promises.Session[[Function]]":["length:n","name:s","prototype:o"],"inspector/promises.Session.prototype":["constructor:f"],"inspector/promises.Network":["dataReceived:f","dataSent:f","loadingFailed:f","loadingFinished:f","requestWillBeSent:f","responseReceived:f","webSocketClosed:f","webSocketCreated:f","webSocketHandshakeResponseReceived:f"],"inspector/promises.NetworkResources":["put:f"],"inspector/promises.DOMStorage":["domStorageItemAdded:f","domStorageItemRemoved:f","domStorageItemUpdated:f","domStorageItemsCleared:f","registerStorage:f"]},"module":{"module.prototype":["_compile:f","constructor:a","isPreloading:a","load:f","parent:a","require:f"],"module._cache":[],"module._pathCache":[],"module._extensions":[".js:f",".json:f",".node:f"],"module.isBuiltin[[Function]]":["length:n","name:s"],"module._findPath[[Function]]":["length:n","name:s","prototype:o"],"module._findPath.prototype":["constructor:f"],"module._nodeModulePaths[[Function]]":["length:n","name:s","prototype:o"],"module._nodeModulePaths.prototype":["constructor:f"],"module._resolveLookupPaths[[Function]]":["length:n","name:s","prototype:o"],"module._resolveLookupPaths.prototype":["constructor:f"],"module._load[[Function]]":["length:n","name:s","prototype:o"],"module._load.prototype":["constructor:f"],"module._resolveFilename[[Function]]":["length:n","name:s","prototype:o"],"module._resolveFilename.prototype":["constructor:f"],"module.createRequire[[Function]]":["length:n","name:s","prototype:o"],"module.createRequire.prototype":["constructor:f"],"module._initPaths[[Function]]":["length:n","name:s"],"module._preloadModules[[Function]]":["length:n","name:s","prototype:o"],"module._preloadModules.prototype":["constructor:f"],"module.syncBuiltinESMExports[[Function]]":["length:n","name:s","prototype:o"],"module.syncBuiltinESMExports.prototype":["constructor:f"],"module.Module[[Function]]":["Module:f","SourceMap:f","_cache:o","_extensions:o","_findPath:f","_initPaths:f","_load:f","_nodeModulePaths:f","_pathCache:o","_preloadModules:f","_readPackage:a","_resolveFilename:f","_resolveLookupPaths:f","_stat:a","builtinModules:o","constants:o","createRequire:f","enableCompileCache:f","findPackageJSON:f","findSourceMap:f","flushCompileCache:f","getCompileCacheDir:f","getSourceMapsSupport:f","globalPaths:o","isBuiltin:f","length:n","name:s","prototype:o","register:f","registerHooks:f","runMain:f","setSourceMapsSupport:f","stripTypeScriptTypes:f","syncBuiltinESMExports:f","wrap:a","wrapper:a"],"module.Module.prototype":["_compile:f","constructor:a","isPreloading:a","load:f","parent:a","require:f"],"module.registerHooks[[Function]]":["length:n","name:s"],"module.runMain[[Function]]":["length:n","name:s","prototype:o"],"module.runMain.prototype":["constructor:f"],"module.register[[Function]]":["length:n","name:s"],"module.constants":["compileCacheStatus:o"],"module.enableCompileCache[[Function]]":["length:n","name:s"],"module.findPackageJSON[[Function]]":["length:n","name:s","prototype:o"],"module.findPackageJSON.prototype":["constructor:f"],"module.flushCompileCache[[Function]]":["length:n","name:s"],"module.getCompileCacheDir[[Function]]":["length:n","name:s"],"module.stripTypeScriptTypes[[Function]]":["length:n","name:s","prototype:o"],"module.stripTypeScriptTypes.prototype":["constructor:f"],"module.findSourceMap[[Function]]":["length:n","name:s","prototype:o"],"module.findSourceMap.prototype":["constructor:f"],"module.SourceMap[[Function]]":["length:n","name:s","prototype:o"],"module.SourceMap.prototype":["@@kMappings:a","constructor:f","findEntry:f","findOrigin:f","lineLengths:a","payload:a"],"module.getSourceMapsSupport[[Function]]":["length:n","name:s","prototype:o"],"module.getSourceMapsSupport.prototype":["constructor:f"],"module.setSourceMapsSupport[[Function]]":["length:n","name:s","prototype:o"],"module.setSourceMapsSupport.prototype":["constructor:f"]},"net":{"net._createServerHandle[[Function]]":["length:n","name:s","prototype:o"],"net._createServerHandle.prototype":["constructor:f"],"net._normalizeArgs[[Function]]":["length:n","name:s","prototype:o"],"net._normalizeArgs.prototype":["constructor:f"],"net.BlockList[[Function]]":["length:n","name:s","prototype:o"],"net.BlockList.prototype":["constructor:f"],"net.SocketAddress[[Function]]":["length:n","name:s","prototype:o"],"net.SocketAddress.prototype":["constructor:f"],"net.BoundSocket[[Function]]":["length:n","name:s","prototype:o"],"net.BoundSocket.prototype":["constructor:f"],"net.connect[[Function]]":["length:n","name:s","prototype:o"],"net.connect.prototype":["constructor:f"],"net.createConnection[[Function]]":["length:n","name:s","prototype:o"],"net.createConnection.prototype":["constructor:f"],"net.createServer[[Function]]":["length:n","name:s","prototype:o"],"net.createServer.prototype":["constructor:f"],"net.isIP[[Function]]":["length:n","name:s","prototype:o"],"net.isIP.prototype":["constructor:f"],"net.isIPv4[[Function]]":["length:n","name:s","prototype:o"],"net.isIPv4.prototype":["constructor:f"],"net.isIPv6[[Function]]":["length:n","name:s","prototype:o"],"net.isIPv6.prototype":["constructor:f"],"net.Server[[Function]]":["length:n","name:s","prototype:o"],"net.Server.prototype":["constructor:f"],"net.Socket[[Function]]":["length:n","name:s","prototype:o"],"net.Socket.prototype":["constructor:f"],"net.Stream[[Function]]":["length:n","name:s","prototype:o"],"net.Stream.prototype":["constructor:f"],"net.getDefaultAutoSelectFamily[[Function]]":["length:n","name:s","prototype:o"],"net.getDefaultAutoSelectFamily.prototype":["constructor:f"],"net.setDefaultAutoSelectFamily[[Function]]":["length:n","name:s","prototype:o"],"net.setDefaultAutoSelectFamily.prototype":["constructor:f"],"net.getDefaultAutoSelectFamilyAttemptTimeout[[Function]]":["length:n","name:s","prototype:o"],"net.getDefaultAutoSelectFamilyAttemptTimeout.prototype":["constructor:f"],"net.setDefaultAutoSelectFamilyAttemptTimeout[[Function]]":["length:n","name:s","prototype:o"],"net.setDefaultAutoSelectFamilyAttemptTimeout.prototype":["constructor:f"]},"node:sea":{"node:sea.isSea[[Function]]":["length:n","name:s","prototype:o"],"node:sea.isSea.prototype":["constructor:f"],"node:sea.getAsset[[Function]]":["length:n","name:s","prototype:o"],"node:sea.getAsset.prototype":["constructor:f"],"node:sea.getRawAsset[[Function]]":["length:n","name:s","prototype:o"],"node:sea.getRawAsset.prototype":["constructor:f"],"node:sea.getAssetAsBlob[[Function]]":["length:n","name:s","prototype:o"],"node:sea.getAssetAsBlob.prototype":["constructor:f"],"node:sea.getAssetKeys[[Function]]":["length:n","name:s","prototype:o"],"node:sea.getAssetKeys.prototype":["constructor:f"]},"node:sqlite":{"node:sqlite.DatabaseSync[[Function]]":["length:n","name:s","prototype:o"],"node:sqlite.DatabaseSync.prototype":["constructor:f"],"node:sqlite.StatementSync[[Function]]":["length:n","name:s","prototype:o"],"node:sqlite.StatementSync.prototype":["constructor:f"],"node:sqlite.Session[[Function]]":["length:n","name:s","prototype:o"],"node:sqlite.Session.prototype":["constructor:f"],"node:sqlite.constants":[],"node:sqlite.backup[[Function]]":["length:n","name:s","prototype:o"],"node:sqlite.backup.prototype":["constructor:f"]},"os":{"os.arch[[Function]]":["length:n","name:s","prototype:o"],"os.arch.prototype":["constructor:f"],"os.availableParallelism[[Function]]":["length:n","name:s","prototype:o"],"os.availableParallelism.prototype":["constructor:f"],"os.cpus[[Function]]":["length:n","name:s","prototype:o"],"os.cpus.prototype":["constructor:f"],"os.endianness[[Function]]":["length:n","name:s","prototype:o"],"os.endianness.prototype":["constructor:f"],"os.freemem[[Function]]":["length:n","name:s","prototype:o"],"os.freemem.prototype":["constructor:f"],"os.getPriority[[Function]]":["length:n","name:s","prototype:o"],"os.getPriority.prototype":["constructor:f"],"os.homedir[[Function]]":["length:n","name:s","prototype:o"],"os.homedir.prototype":["constructor:f"],"os.hostname[[Function]]":["length:n","name:s","prototype:o"],"os.hostname.prototype":["constructor:f"],"os.loadavg[[Function]]":["length:n","name:s","prototype:o"],"os.loadavg.prototype":["constructor:f"],"os.networkInterfaces[[Function]]":["length:n","name:s","prototype:o"],"os.networkInterfaces.prototype":["constructor:f"],"os.platform[[Function]]":["length:n","name:s","prototype:o"],"os.platform.prototype":["constructor:f"],"os.release[[Function]]":["length:n","name:s","prototype:o"],"os.release.prototype":["constructor:f"],"os.setPriority[[Function]]":["length:n","name:s","prototype:o"],"os.setPriority.prototype":["constructor:f"],"os.tmpdir[[Function]]":["length:n","name:s","prototype:o"],"os.tmpdir.prototype":["constructor:f"],"os.totalmem[[Function]]":["length:n","name:s","prototype:o"],"os.totalmem.prototype":["constructor:f"],"os.type[[Function]]":["length:n","name:s","prototype:o"],"os.type.prototype":["constructor:f"],"os.userInfo[[Function]]":["length:n","name:s","prototype:o"],"os.userInfo.prototype":["constructor:f"],"os.uptime[[Function]]":["length:n","name:s","prototype:o"],"os.uptime.prototype":["constructor:f"],"os.version[[Function]]":["length:n","name:s","prototype:o"],"os.version.prototype":["constructor:f"],"os.machine[[Function]]":["length:n","name:s","prototype:o"],"os.machine.prototype":["constructor:f"],"os.constants":["dlopen:o","errno:o","priority:o","signals:o"]},"path":{"path.resolve[[Function]]":["length:n","name:s"],"path.normalize[[Function]]":["length:n","name:s"],"path.isAbsolute[[Function]]":["length:n","name:s"],"path.join[[Function]]":["length:n","name:s"],"path.relative[[Function]]":["length:n","name:s"],"path.toNamespacedPath[[Function]]":["length:n","name:s"],"path.dirname[[Function]]":["length:n","name:s"],"path.basename[[Function]]":["length:n","name:s"],"path.extname[[Function]]":["length:n","name:s"],"path.format[[Function]]":["length:n","name:s"],"path.parse[[Function]]":["length:n","name:s"],"path.matchesGlob[[Function]]":["length:n","name:s"],"path.win32":["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],"path.posix":["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],"path._makeLong[[Function]]":["length:n","name:s"]},"path/posix":{"path/posix.resolve[[Function]]":["length:n","name:s"],"path/posix.normalize[[Function]]":["length:n","name:s"],"path/posix.isAbsolute[[Function]]":["length:n","name:s"],"path/posix.join[[Function]]":["length:n","name:s"],"path/posix.relative[[Function]]":["length:n","name:s"],"path/posix.toNamespacedPath[[Function]]":["length:n","name:s"],"path/posix.dirname[[Function]]":["length:n","name:s"],"path/posix.basename[[Function]]":["length:n","name:s"],"path/posix.extname[[Function]]":["length:n","name:s"],"path/posix.format[[Function]]":["length:n","name:s"],"path/posix.parse[[Function]]":["length:n","name:s"],"path/posix.matchesGlob[[Function]]":["length:n","name:s"],"path/posix.win32":["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],"path/posix.posix":["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],"path/posix._makeLong[[Function]]":["length:n","name:s"]},"path/win32":{"path/win32.resolve[[Function]]":["length:n","name:s"],"path/win32.normalize[[Function]]":["length:n","name:s"],"path/win32.isAbsolute[[Function]]":["length:n","name:s"],"path/win32.join[[Function]]":["length:n","name:s"],"path/win32.relative[[Function]]":["length:n","name:s"],"path/win32.toNamespacedPath[[Function]]":["length:n","name:s"],"path/win32.dirname[[Function]]":["length:n","name:s"],"path/win32.basename[[Function]]":["length:n","name:s"],"path/win32.extname[[Function]]":["length:n","name:s"],"path/win32.format[[Function]]":["length:n","name:s"],"path/win32.parse[[Function]]":["length:n","name:s"],"path/win32.matchesGlob[[Function]]":["length:n","name:s"],"path/win32.win32":["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],"path/win32.posix":["_makeLong:f","basename:f","delimiter:s","dirname:f","extname:f","format:f","isAbsolute:f","join:f","matchesGlob:f","normalize:f","parse:f","posix:o","relative:f","resolve:f","sep:s","toNamespacedPath:f","win32:o"],"path/win32._makeLong[[Function]]":["length:n","name:s"]},"perf_hooks":{"perf_hooks.Performance[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.Performance.prototype":["constructor:f"],"perf_hooks.PerformanceEntry[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.PerformanceEntry.prototype":["constructor:f"],"perf_hooks.PerformanceMark[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.PerformanceMark.prototype":["constructor:f"],"perf_hooks.PerformanceMeasure[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.PerformanceMeasure.prototype":["constructor:f"],"perf_hooks.PerformanceObserver[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.PerformanceObserver.prototype":["constructor:f"],"perf_hooks.PerformanceObserverEntryList[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.PerformanceObserverEntryList.prototype":["constructor:f"],"perf_hooks.PerformanceResourceTiming[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.PerformanceResourceTiming.prototype":["constructor:f"],"perf_hooks.monitorEventLoopDelay[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.monitorEventLoopDelay.prototype":["constructor:f"],"perf_hooks.eventLoopUtilization[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.eventLoopUtilization.prototype":["constructor:f"],"perf_hooks.timerify[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.timerify.prototype":["constructor:f"],"perf_hooks.createHistogram[[Function]]":["length:n","name:s","prototype:o"],"perf_hooks.createHistogram.prototype":["constructor:f"],"perf_hooks.performance":["nodeTiming:l","now:f","timeOrigin:n"],"perf_hooks.constants":[]},"process":{"process.versions":["acorn:s","ada:s","amaro:s","ares:s","brotli:s","cldr:s","icu:s","libffi:s","lief:s","llhttp:s","merve:s","modules:s","napi:s","nbytes:s","ncrypto:s","nghttp2:s","nghttp3:s","ngtcp2:s","node:s","openssl:s","simdjson:s","simdutf:s","sqlite:s","tz:s","undici:s","unicode:s","uv:s","uvwasi:s","v8:s","zlib:s","zstd:s"],"process.release":["headersUrl:s","name:s","sourceUrl:s"],"process._rawDebug[[Function]]":["length:n","name:s"],"process.binding[[Function]]":["length:n","name:s"],"process._linkedBinding[[Function]]":["length:n","name:s"],"process._events":["exit:f","newListener:f","removeListener:f","warning:f"],"process.config":["target_defaults:o","variables:o"],"process.dlopen[[Function]]":["length:n","name:s"],"process.uptime[[Function]]":["length:n","name:s"],"process._getActiveRequests[[Function]]":["length:n","name:s"],"process._getActiveHandles[[Function]]":["length:n","name:s"],"process.getActiveResourcesInfo[[Function]]":["length:n","name:s"],"process.reallyExit[[Function]]":["length:n","name:s"],"process._kill[[Function]]":["length:n","name:s"],"process.loadEnvFile[[Function]]":["length:n","name:s","prototype:o"],"process.loadEnvFile.prototype":["constructor:f"],"process.cpuUsage[[Function]]":["length:n","name:s"],"process.threadCpuUsage[[Function]]":["length:n","name:s","prototype:o"],"process.threadCpuUsage.prototype":["constructor:f"],"process.resourceUsage[[Function]]":["length:n","name:s"],"process.memoryUsage[[Function]]":["length:n","name:s"],"process.constrainedMemory[[Function]]":["length:n","name:s"],"process.availableMemory[[Function]]":["length:n","name:s"],"process.kill[[Function]]":["length:n","name:s"],"process.exit[[Function]]":["length:n","name:s","prototype:o"],"process.exit.prototype":["constructor:f"],"process.execve[[Function]]":["length:n","name:s","prototype:o"],"process.execve.prototype":["constructor:f"],"process.ref[[Function]]":["length:n","name:s","prototype:o"],"process.ref.prototype":["constructor:f"],"process.unref[[Function]]":["length:n","name:s","prototype:o"],"process.unref.prototype":["constructor:f"],"process.hrtime[[Function]]":["length:n","name:s"],"process.openStdin[[Function]]":["length:n","name:s","prototype:o"],"process.openStdin.prototype":["constructor:f"],"process.getuid[[Function]]":["length:n","name:s"],"process.geteuid[[Function]]":["length:n","name:s"],"process.getgid[[Function]]":["length:n","name:s"],"process.getegid[[Function]]":["length:n","name:s"],"process.getgroups[[Function]]":["length:n","name:s"],"process.features":["cached_builtins:a","debug:b","inspector:b","ipv6:b","openssl_is_boringssl:b","quic:a","require_module:a","tls:b","tls_alpn:b","tls_ocsp:b","tls_sni:b","typescript:a","uv:b"],"process._fatalException[[Function]]":["length:n","name:s","prototype:o"],"process._fatalException.prototype":["constructor:f"],"process.setUncaughtExceptionCaptureCallback[[Function]]":["length:n","name:s","prototype:o"],"process.setUncaughtExceptionCaptureCallback.prototype":["constructor:f"],"process.addUncaughtExceptionCaptureCallback[[Function]]":["length:n","name:s","prototype:o"],"process.addUncaughtExceptionCaptureCallback.prototype":["constructor:f"],"process.hasUncaughtExceptionCaptureCallback[[Function]]":["length:n","name:s","prototype:o"],"process.hasUncaughtExceptionCaptureCallback.prototype":["constructor:f"],"process.emitWarning[[Function]]":["length:n","name:s","prototype:o"],"process.emitWarning.prototype":["constructor:f"],"process.nextTick[[Function]]":["length:n","name:s","prototype:o"],"process.nextTick.prototype":["constructor:f"],"process._tickCallback[[Function]]":["length:n","name:s","prototype:o"],"process._tickCallback.prototype":["constructor:f"],"process.setSourceMapsEnabled[[Function]]":["length:n","name:s","prototype:o"],"process.setSourceMapsEnabled.prototype":["constructor:f"],"process.getBuiltinModule[[Function]]":["length:n","name:s","prototype:o"],"process.getBuiltinModule.prototype":["constructor:f"],"process.abort[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.abort.prototype":["constructor:f"],"process.chdir[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.chdir.prototype":["constructor:f"],"process.umask[[Function]]":["length:n","name:s"],"process.cwd[[Function]]":["length:n","name:s"],"process.initgroups[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.initgroups.prototype":["constructor:f"],"process.setgroups[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.setgroups.prototype":["constructor:f"],"process.setegid[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.setegid.prototype":["constructor:f"],"process.seteuid[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.seteuid.prototype":["constructor:f"],"process.setgid[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.setgid.prototype":["constructor:f"],"process.setuid[[Function]]":["disabled:b","length:n","name:s","prototype:o"],"process.setuid.prototype":["constructor:f"],"process.report":["getReport:f","writeReport:f"],"process.permission":["drop:f","has:f"],"process._debugProcess[[Function]]":["length:n","name:s"],"process.allowedNodeEnvironmentFlags":["@@internal properties:o"],"process.allowedNodeEnvironmentFlags[[Prototype]]0":["@@Symbol.iterator:f","add:f","clear:f","constructor:f","delete:f","entries:f","forEach:f","has:f","keys:f","size:a","values:f"]},"punycode":{"punycode.ucs2":["decode:f","encode:f"],"punycode.decode[[Function]]":["length:n","name:s","prototype:o"],"punycode.decode.prototype":["constructor:f"],"punycode.encode[[Function]]":["length:n","name:s","prototype:o"],"punycode.encode.prototype":["constructor:f"],"punycode.toASCII[[Function]]":["length:n","name:s","prototype:o"],"punycode.toASCII.prototype":["constructor:f"],"punycode.toUnicode[[Function]]":["length:n","name:s","prototype:o"],"punycode.toUnicode.prototype":["constructor:f"]},"querystring":{"querystring.unescapeBuffer[[Function]]":["length:n","name:s","prototype:o"],"querystring.unescapeBuffer.prototype":["constructor:f"],"querystring.unescape[[Function]]":["length:n","name:s","prototype:o"],"querystring.unescape.prototype":["constructor:f"],"querystring.escape[[Function]]":["length:n","name:s","prototype:o"],"querystring.escape.prototype":["constructor:f"],"querystring.stringify[[Function]]":["length:n","name:s","prototype:o"],"querystring.stringify.prototype":["constructor:f"],"querystring.encode[[Function]]":["length:n","name:s","prototype:o"],"querystring.encode.prototype":["constructor:f"],"querystring.parse[[Function]]":["length:n","name:s","prototype:o"],"querystring.parse.prototype":["constructor:f"],"querystring.decode[[Function]]":["length:n","name:s","prototype:o"],"querystring.decode.prototype":["constructor:f"]},"readline":{"readline.Interface[[Function]]":["length:n","name:s","prototype:o"],"readline.Interface.prototype":["@@_addHistory:a","@@_deleteLeft:a","@@_deleteLineLeft:a","@@_deleteLineRight:a","@@_deleteRight:a","@@_deleteWordLeft:a","@@_deleteWordRight:a","@@_getDisplayPos:a","@@_historyNext:a","@@_historyPrev:a","@@_insertString:a","@@_line:a","@@_moveCursor:a","@@_normalWrite:a","@@_onLine:a","@@_refreshLine:a","@@_setRawMode:a","@@_tabComplete:a","@@_ttyWrite:a","@@_wordLeft:a","@@_wordRight:a","@@_writeToOutput:a","_addHistory:f","_decoder:a","_deleteLeft:f","_deleteLineLeft:f","_deleteLineRight:f","_deleteRight:f","_deleteWordLeft:f","_deleteWordRight:f","_getCursorPos:f","_getDisplayPos:f","_historyNext:f","_historyPrev:f","_insertString:f","_line:f","_line_buffer:a","_moveCursor:f","_normalWrite:f","_oldPrompt:a","_onLine:f","_previousKey:a","_prompt:a","_questionCallback:a","_refreshLine:f","_sawKeyPress:a","_sawReturnAt:a","_setRawMode:f","_tabComplete:f","_ttyWrite:f","_wordLeft:f","_wordRight:f","_writeToOutput:f","constructor:f","question:f"],"readline.Interface.prototype[[Prototype]]0":["@@Symbol.asyncIterator:f","@@Symbol.dispose:f","@@_addHistory:f","@@_addNewLineOnTTY:f","@@_beforeEdit:f","@@_deleteLeft:f","@@_deleteLineLeft:f","@@_deleteLineRight:f","@@_deleteRight:f","@@_deleteWordLeft:f","@@_deleteWordRight:f","@@_getDisplayPos:f","@@_historyNext:f","@@_historyPrev:f","@@_insertString:f","@@_line:f","@@_moveCursor:f","@@_moveDownOrHistoryNext:f","@@_moveUpOrHistoryPrev:f","@@_multilineMove:f","@@_normalWrite:f","@@_onLine:f","@@_pushToKillRing:f","@@_pushToUndoStack:f","@@_redo:f","@@_refreshLine:f","@@_restorePreviousState:f","@@_savePreviousState:f","@@_setLine:f","@@_setRawMode:f","@@_tabComplete:f","@@_tabCompleter:f","@@_ttyWrite:f","@@_undo:f","@@_wordLeft:f","@@_wordRight:f","@@_writeToOutput:f","@@_yank:f","@@_yankPop:f","@@kQuestion:f","@@kQuestionCancel:f","clearLine:f","close:f","columns:a","constructor:f","getCursorPos:f","getPrompt:f","pause:f","prompt:f","resume:f","setPrompt:f","setupHistoryManager:f","write:f"],"readline.Interface.prototype[[Prototype]]1":["constructor:f"],"readline.Interface.prototype[[Prototype]]2":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"readline.clearLine[[Function]]":["length:n","name:s","prototype:o"],"readline.clearLine.prototype":["constructor:f"],"readline.clearScreenDown[[Function]]":["length:n","name:s","prototype:o"],"readline.clearScreenDown.prototype":["constructor:f"],"readline.createInterface[[Function]]":["length:n","name:s","prototype:o"],"readline.createInterface.prototype":["constructor:f"],"readline.cursorTo[[Function]]":["length:n","name:s","prototype:o"],"readline.cursorTo.prototype":["constructor:f"],"readline.emitKeypressEvents[[Function]]":["length:n","name:s","prototype:o"],"readline.emitKeypressEvents.prototype":["constructor:f"],"readline.moveCursor[[Function]]":["length:n","name:s","prototype:o"],"readline.moveCursor.prototype":["constructor:f"],"readline.promises":["Interface:f","Readline:f","createInterface:f"]},"readline/promises":{"readline/promises.Interface[[Function]]":["length:n","name:s","prototype:o"],"readline/promises.Interface.prototype":["constructor:f","question:f"],"readline/promises.Interface.prototype[[Prototype]]0":["@@Symbol.asyncIterator:f","@@Symbol.dispose:f","@@_addHistory:f","@@_addNewLineOnTTY:f","@@_beforeEdit:f","@@_deleteLeft:f","@@_deleteLineLeft:f","@@_deleteLineRight:f","@@_deleteRight:f","@@_deleteWordLeft:f","@@_deleteWordRight:f","@@_getDisplayPos:f","@@_historyNext:f","@@_historyPrev:f","@@_insertString:f","@@_line:f","@@_moveCursor:f","@@_moveDownOrHistoryNext:f","@@_moveUpOrHistoryPrev:f","@@_multilineMove:f","@@_normalWrite:f","@@_onLine:f","@@_pushToKillRing:f","@@_pushToUndoStack:f","@@_redo:f","@@_refreshLine:f","@@_restorePreviousState:f","@@_savePreviousState:f","@@_setLine:f","@@_setRawMode:f","@@_tabComplete:f","@@_tabCompleter:f","@@_ttyWrite:f","@@_undo:f","@@_wordLeft:f","@@_wordRight:f","@@_writeToOutput:f","@@_yank:f","@@_yankPop:f","@@kQuestion:f","@@kQuestionCancel:f","clearLine:f","close:f","columns:a","constructor:f","getCursorPos:f","getPrompt:f","pause:f","prompt:f","resume:f","setPrompt:f","setupHistoryManager:f","write:f"],"readline/promises.Interface.prototype[[Prototype]]1":["constructor:f"],"readline/promises.Interface.prototype[[Prototype]]2":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"readline/promises.Readline[[Function]]":["length:n","name:s","prototype:o"],"readline/promises.Readline.prototype":["clearLine:f","clearScreenDown:f","commit:f","constructor:f","cursorTo:f","moveCursor:f","rollback:f"],"readline/promises.createInterface[[Function]]":["length:n","name:s","prototype:o"],"readline/promises.createInterface.prototype":["constructor:f"]},"stream":{"stream.prototype":["constructor:f","eventNames:f","pipe:f"],"stream.prototype[[Prototype]]0":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream.isDestroyed[[Function]]":["length:n","name:s","prototype:o"],"stream.isDestroyed.prototype":["constructor:f"],"stream.isDisturbed[[Function]]":["length:n","name:s","prototype:o"],"stream.isDisturbed.prototype":["constructor:f"],"stream.isErrored[[Function]]":["length:n","name:s","prototype:o"],"stream.isErrored.prototype":["constructor:f"],"stream.isReadable[[Function]]":["length:n","name:s","prototype:o"],"stream.isReadable.prototype":["constructor:f"],"stream.isWritable[[Function]]":["length:n","name:s","prototype:o"],"stream.isWritable.prototype":["constructor:f"],"stream.Readable[[Function]]":["ReadableState:f","_fromList:f","from:f","fromWeb:f","length:n","name:s","prototype:o","toWeb:f","wrap:f"],"stream.Readable.prototype":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"stream.Readable.prototype[[Prototype]]0":["constructor:f","eventNames:f","pipe:f"],"stream.Readable.prototype[[Prototype]]1":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream.Writable[[Function]]":["@@Symbol.hasInstance:f","WritableState:f","fromWeb:f","length:n","name:s","prototype:o","toWeb:f"],"stream.Writable.prototype":["@@Symbol.asyncDispose:f","@@nodejs.rejection:f","_destroy:f","_undestroy:f","_write:f","_writev:l","closed:a","constructor:f","cork:f","destroy:f","destroyed:a","end:f","errored:a","pipe:f","setDefaultEncoding:f","uncork:f","writable:a","writableAborted:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"stream.Writable.prototype[[Prototype]]0":["constructor:f","eventNames:f","pipe:f"],"stream.Writable.prototype[[Prototype]]1":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream.Duplex[[Function]]":["from:f","fromWeb:f","length:n","name:s","prototype:o","toWeb:f"],"stream.Duplex.prototype":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"stream.Duplex.prototype[[Prototype]]0":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"stream.Duplex.prototype[[Prototype]]1":["constructor:f","eventNames:f","pipe:f"],"stream.Duplex.prototype[[Prototype]]2":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream.Transform[[Function]]":["length:n","name:s","prototype:o"],"stream.Transform.prototype":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"stream.Transform.prototype[[Prototype]]0":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"stream.Transform.prototype[[Prototype]]1":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"stream.Transform.prototype[[Prototype]]2":["constructor:f","eventNames:f","pipe:f"],"stream.Transform.prototype[[Prototype]]3":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream.PassThrough[[Function]]":["length:n","name:s","prototype:o"],"stream.PassThrough.prototype":["_transform:f","constructor:f"],"stream.PassThrough.prototype[[Prototype]]0":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"stream.PassThrough.prototype[[Prototype]]1":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"stream.PassThrough.prototype[[Prototype]]2":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"stream.PassThrough.prototype[[Prototype]]3":["constructor:f","eventNames:f","pipe:f"],"stream.PassThrough.prototype[[Prototype]]4":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream.duplexPair[[Function]]":["length:n","name:s","prototype:o"],"stream.duplexPair.prototype":["constructor:f"],"stream.pipeline[[Function]]":["@@nodejs.util.promisify.custom:a","length:n","name:s","prototype:o"],"stream.pipeline.prototype":["constructor:f"],"stream.addAbortSignal[[Function]]":["length:n","name:s","prototype:o"],"stream.addAbortSignal.prototype":["constructor:f"],"stream.finished[[Function]]":["@@nodejs.util.promisify.custom:a","length:n","name:s","prototype:o"],"stream.finished.prototype":["constructor:f"],"stream.destroy[[Function]]":["length:n","name:s","prototype:o"],"stream.destroy.prototype":["constructor:f"],"stream.compose[[Function]]":["length:n","name:s","prototype:o"],"stream.compose.prototype":["constructor:f"],"stream.setDefaultHighWaterMark[[Function]]":["length:n","name:s","prototype:o"],"stream.setDefaultHighWaterMark.prototype":["constructor:f"],"stream.getDefaultHighWaterMark[[Function]]":["length:n","name:s","prototype:o"],"stream.getDefaultHighWaterMark.prototype":["constructor:f"],"stream.Stream[[Function]]":["Duplex:f","PassThrough:f","Readable:f","Stream:f","Transform:f","Writable:f","_isArrayBufferView:f","_isUint8Array:f","_uint8ArrayToBuffer:f","addAbortSignal:f","compose:f","destroy:f","duplexPair:f","finished:f","getDefaultHighWaterMark:f","isDestroyed:f","isDisturbed:f","isErrored:f","isReadable:f","isWritable:f","length:n","name:s","pipeline:f","promises:a","prototype:o","setDefaultHighWaterMark:f"],"stream.Stream.prototype":["constructor:f","eventNames:f","pipe:f"],"stream.Stream.prototype[[Prototype]]0":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"stream._isArrayBufferView[[Function]]":["length:n","name:s"],"stream._isUint8Array[[Function]]":["length:n","name:s","prototype:o"],"stream._isUint8Array.prototype":["constructor:f"],"stream._uint8ArrayToBuffer[[Function]]":["length:n","name:s","prototype:o"],"stream._uint8ArrayToBuffer.prototype":["constructor:f"]},"stream/consumers":{"stream/consumers.arrayBuffer[[Function]]":["length:n","name:s"],"stream/consumers.blob[[Function]]":["length:n","name:s"],"stream/consumers.buffer[[Function]]":["length:n","name:s"],"stream/consumers.bytes[[Function]]":["length:n","name:s"],"stream/consumers.text[[Function]]":["length:n","name:s"],"stream/consumers.json[[Function]]":["length:n","name:s"]},"stream/promises":{"stream/promises.finished[[Function]]":["length:n","name:s","prototype:o"],"stream/promises.finished.prototype":["constructor:f"],"stream/promises.pipeline[[Function]]":["length:n","name:s","prototype:o"],"stream/promises.pipeline.prototype":["constructor:f"]},"stream/web":{"stream/web.ReadableStream[[Function]]":["from:f","length:n","name:s","prototype:o"],"stream/web.ReadableStream.prototype":["@@Symbol.asyncIterator:f","@@Symbol.toStringTag:s","@@messaging_deserialize_symbol:f","@@messaging_transfer_list_symbol:f","@@messaging_transfer_symbol:f","@@nodejs.stream.disturbed:a","@@nodejs.stream.errored:a","@@nodejs.stream.readable:a","@@nodejs.util.inspect.custom:f","@@nodejs.webstream.controllerErrorFunction:f","@@nodejs.webstream.isClosedPromise:a","cancel:f","constructor:f","getReader:f","locked:a","pipeThrough:f","pipeTo:f","tee:f","values:f"],"stream/web.ReadableStreamTee[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ReadableStreamTee.prototype":["constructor:f"],"stream/web.ReadableStreamDefaultReader[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ReadableStreamDefaultReader.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","cancel:f","closed:a","constructor:f","read:f","releaseLock:f"],"stream/web.ReadableStreamBYOBReader[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ReadableStreamBYOBReader.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","cancel:f","closed:a","constructor:f","read:f","releaseLock:f"],"stream/web.ReadableStreamBYOBRequest[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ReadableStreamBYOBRequest.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","respond:f","respondWithNewView:f","view:a"],"stream/web.ReadableByteStreamController[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ReadableByteStreamController.prototype":["@@Symbol.toStringTag:s","@@kCancel:f","@@kPull:f","@@kRelease:f","@@nodejs.util.inspect.custom:f","byobRequest:a","close:f","constructor:f","desiredSize:a","enqueue:f","error:f"],"stream/web.ReadableStreamDefaultController[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ReadableStreamDefaultController.prototype":["@@Symbol.toStringTag:s","@@kCancel:f","@@kPull:f","@@kRelease:f","@@nodejs.util.inspect.custom:f","close:f","constructor:f","desiredSize:a","enqueue:f","error:f"],"stream/web.TransformStream[[Function]]":["length:n","name:s","prototype:o"],"stream/web.TransformStream.prototype":["@@Symbol.toStringTag:s","@@messaging_deserialize_symbol:f","@@messaging_transfer_list_symbol:f","@@messaging_transfer_symbol:f","@@nodejs.util.inspect.custom:f","constructor:f","readable:a","writable:a"],"stream/web.TransformStreamDefaultController[[Function]]":["length:n","name:s","prototype:o"],"stream/web.TransformStreamDefaultController.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","desiredSize:a","enqueue:f","error:f","terminate:f"],"stream/web.WritableStream[[Function]]":["length:n","name:s","prototype:o"],"stream/web.WritableStream.prototype":["@@Symbol.toStringTag:s","@@messaging_deserialize_symbol:f","@@messaging_transfer_list_symbol:f","@@messaging_transfer_symbol:f","@@nodejs.stream.errored:a","@@nodejs.stream.writable:a","@@nodejs.util.inspect.custom:f","@@nodejs.webstream.controllerErrorFunction:f","@@nodejs.webstream.isClosedPromise:a","abort:f","close:f","constructor:f","getWriter:f","locked:a"],"stream/web.WritableStreamDefaultWriter[[Function]]":["length:n","name:s","prototype:o"],"stream/web.WritableStreamDefaultWriter.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","abort:f","close:f","closed:a","constructor:f","desiredSize:a","ready:a","releaseLock:f","write:f"],"stream/web.WritableStreamDefaultController[[Function]]":["length:n","name:s","prototype:o"],"stream/web.WritableStreamDefaultController.prototype":["@@Symbol.toStringTag:s","@@kAbort:f","@@kError:f","@@nodejs.util.inspect.custom:f","constructor:f","error:f","signal:a"],"stream/web.ByteLengthQueuingStrategy[[Function]]":["length:n","name:s","prototype:o"],"stream/web.ByteLengthQueuingStrategy.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","highWaterMark:a","size:a"],"stream/web.CountQueuingStrategy[[Function]]":["length:n","name:s","prototype:o"],"stream/web.CountQueuingStrategy.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","highWaterMark:a","size:a"],"stream/web.TextEncoderStream[[Function]]":["length:n","name:s","prototype:o"],"stream/web.TextEncoderStream.prototype":["@@nodejs.util.inspect.custom:f","constructor:f","encoding:a","readable:a","writable:a"],"stream/web.TextDecoderStream[[Function]]":["length:n","name:s","prototype:o"],"stream/web.TextDecoderStream.prototype":["@@nodejs.util.inspect.custom:f","constructor:f","encoding:a","fatal:a","ignoreBOM:a","readable:a","writable:a"],"stream/web.CompressionStream[[Function]]":["length:n","name:s","prototype:o"],"stream/web.CompressionStream.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","readable:a","writable:a"],"stream/web.DecompressionStream[[Function]]":["length:n","name:s","prototype:o"],"stream/web.DecompressionStream.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","readable:a","writable:a"]},"string_decoder":{"string_decoder.StringDecoder[[Function]]":["length:n","name:s","prototype:o"],"string_decoder.StringDecoder.prototype":["constructor:f","end:f","lastChar:a","lastNeed:a","lastTotal:a","text:f","write:f"]},"sys":{"sys._errnoException[[Function]]":["length:n","name:s","prototype:o"],"sys._errnoException.prototype":["constructor:f"],"sys._exceptionWithHostPort[[Function]]":["length:n","name:s","prototype:o"],"sys._exceptionWithHostPort.prototype":["constructor:f"],"sys._extend[[Function]]":["length:n","name:s","prototype:o"],"sys._extend.prototype":["constructor:f"],"sys.callbackify[[Function]]":["length:n","name:s","prototype:o"],"sys.callbackify.prototype":["constructor:f"],"sys.convertProcessSignalToExitCode[[Function]]":["length:n","name:s","prototype:o"],"sys.convertProcessSignalToExitCode.prototype":["constructor:f"],"sys.debug[[Function]]":["length:n","name:s","prototype:o"],"sys.debug.prototype":["constructor:f"],"sys.debuglog[[Function]]":["length:n","name:s","prototype:o"],"sys.debuglog.prototype":["constructor:f"],"sys.deprecate[[Function]]":["length:n","name:s","prototype:o"],"sys.deprecate.prototype":["constructor:f"],"sys.format[[Function]]":["length:n","name:s","prototype:o"],"sys.format.prototype":["constructor:f"],"sys.styleText[[Function]]":["length:n","name:s","prototype:o"],"sys.styleText.prototype":["constructor:f"],"sys.formatWithOptions[[Function]]":["length:n","name:s","prototype:o"],"sys.formatWithOptions.prototype":["constructor:f"],"sys.getCallSites[[Function]]":["length:n","name:s","prototype:o"],"sys.getCallSites.prototype":["constructor:f"],"sys.getSystemErrorMap[[Function]]":["length:n","name:s","prototype:o"],"sys.getSystemErrorMap.prototype":["constructor:f"],"sys.getSystemErrorName[[Function]]":["length:n","name:s","prototype:o"],"sys.getSystemErrorName.prototype":["constructor:f"],"sys.getSystemErrorMessage[[Function]]":["length:n","name:s","prototype:o"],"sys.getSystemErrorMessage.prototype":["constructor:f"],"sys.inherits[[Function]]":["length:n","name:s","prototype:o"],"sys.inherits.prototype":["constructor:f"],"sys.inspect[[Function]]":["colors:o","custom:y","defaultOptions:a","length:n","name:s","prototype:o","styles:o"],"sys.inspect.prototype":["constructor:f"],"sys.isArray[[Function]]":["length:n","name:s","prototype:o"],"sys.isArray.prototype":["constructor:f"],"sys.isDeepStrictEqual[[Function]]":["length:n","name:s"],"sys.promisify[[Function]]":["custom:y","length:n","name:s","prototype:o"],"sys.promisify.prototype":["constructor:f"],"sys.stripVTControlCharacters[[Function]]":["length:n","name:s","prototype:o"],"sys.stripVTControlCharacters.prototype":["constructor:f"],"sys.toUSVString[[Function]]":["length:n","name:s"],"sys.types":["isAnyArrayBuffer:f","isArgumentsObject:f","isArrayBuffer:f","isArrayBufferView:f","isAsyncFunction:f","isBigInt64Array:f","isBigIntObject:f","isBigUint64Array:f","isBooleanObject:f","isBoxedPrimitive:f","isCryptoKey:f","isDataView:f","isDate:f","isExternal:f","isFloat16Array:f","isFloat32Array:f","isFloat64Array:f","isGeneratorFunction:f","isGeneratorObject:f","isInt16Array:f","isInt32Array:f","isInt8Array:f","isKeyObject:f","isMap:f","isMapIterator:f","isModuleNamespaceObject:f","isNativeError:f","isNumberObject:f","isPromise:f","isProxy:f","isRegExp:f","isSet:f","isSetIterator:f","isSharedArrayBuffer:f","isStringObject:f","isSymbolObject:f","isTypedArray:f","isUint16Array:f","isUint32Array:f","isUint8Array:f","isUint8ClampedArray:f","isWeakMap:f","isWeakSet:f"],"sys.parseEnv[[Function]]":["length:n","name:s","prototype:o"],"sys.parseEnv.prototype":["constructor:f"],"sys.parseArgs[[Function]]":["length:n","name:s"],"sys.TextDecoder[[Function]]":["length:n","name:s","prototype:o"],"sys.TextDecoder.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","decode:f","encoding:a","fatal:a","ignoreBOM:a"],"sys.TextEncoder[[Function]]":["length:n","name:s","prototype:o"],"sys.TextEncoder.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","encode:f","encodeInto:f","encoding:a"],"sys.MIMEType[[Function]]":["length:n","name:s","prototype:o"],"sys.MIMEType.prototype":["constructor:f","essence:a","params:a","subtype:a","toJSON:f","toString:f","type:a"],"sys.MIMEParams[[Function]]":["length:n","name:s","prototype:o"],"sys.MIMEParams.prototype":["@@Symbol.iterator:f","constructor:f","delete:f","entries:f","get:f","has:f","keys:f","set:f","toJSON:f","toString:f","values:f"],"sys.diff[[Function]]":["length:n","name:s","prototype:o"],"sys.diff.prototype":["constructor:f"],"sys.setTraceSigInt[[Function]]":["length:n","name:s","prototype:o"],"sys.setTraceSigInt.prototype":["constructor:f"]},"timers":{"timers.setTimeout[[Function]]":["@@nodejs.util.promisify.custom:a","length:n","name:s","prototype:o"],"timers.setTimeout.prototype":["constructor:f"],"timers.clearTimeout[[Function]]":["length:n","name:s","prototype:o"],"timers.clearTimeout.prototype":["constructor:f"],"timers.setImmediate[[Function]]":["@@nodejs.util.promisify.custom:a","length:n","name:s","prototype:o"],"timers.setImmediate.prototype":["constructor:f"],"timers.clearImmediate[[Function]]":["length:n","name:s","prototype:o"],"timers.clearImmediate.prototype":["constructor:f"],"timers.setInterval[[Function]]":["length:n","name:s","prototype:o"],"timers.setInterval.prototype":["constructor:f"],"timers.clearInterval[[Function]]":["length:n","name:s","prototype:o"],"timers.clearInterval.prototype":["constructor:f"]},"timers/promises":{"timers/promises.setTimeout[[Function]]":["length:n","name:s","prototype:o"],"timers/promises.setTimeout.prototype":["constructor:f"],"timers/promises.setImmediate[[Function]]":["length:n","name:s","prototype:o"],"timers/promises.setImmediate.prototype":["constructor:f"],"timers/promises.setInterval[[Function]]":["length:n","name:s","prototype:o"],"timers/promises.setInterval.prototype":[],"timers/promises.setInterval.prototype[[Prototype]]0":["@@Symbol.toStringTag:s","constructor:o","next:f","return:f","throw:f"],"timers/promises.setInterval.prototype[[Prototype]]1":["@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f"],"timers/promises.scheduler":["@@kScheduler:b"],"timers/promises.scheduler[[Prototype]]0":["constructor:f","wait:f","yield:f"]},"tls":{"tls.getCiphers[[Function]]":["length:n","name:s","prototype:o"],"tls.getCiphers.prototype":["constructor:f"],"tls.getCertificateCompressionAlgorithms[[Function]]":["length:n","name:s","prototype:o"],"tls.getCertificateCompressionAlgorithms.prototype":["constructor:f"],"tls.getCACertificates[[Function]]":["length:n","name:s","prototype:o"],"tls.getCACertificates.prototype":["constructor:f"],"tls.setDefaultCACertificates[[Function]]":["length:n","name:s","prototype:o"],"tls.setDefaultCACertificates.prototype":["constructor:f"],"tls.convertALPNProtocols[[Function]]":["length:n","name:s","prototype:o"],"tls.convertALPNProtocols.prototype":["constructor:f"],"tls.checkServerIdentity[[Function]]":["length:n","name:s","prototype:o"],"tls.checkServerIdentity.prototype":["constructor:f"],"tls.createSecureContext[[Function]]":["length:n","name:s","prototype:o"],"tls.createSecureContext.prototype":["constructor:f"],"tls.SecureContext[[Function]]":["length:n","name:s","prototype:o"],"tls.SecureContext.prototype":["constructor:f"],"tls.TLSSocket[[Function]]":["length:n","name:s","prototype:o"],"tls.TLSSocket.prototype":["constructor:f"],"tls.Server[[Function]]":["length:n","name:s","prototype:o"],"tls.Server.prototype":["constructor:f"],"tls.createServer[[Function]]":["length:n","name:s","prototype:o"],"tls.createServer.prototype":["constructor:f"],"tls.connect[[Function]]":["length:n","name:s","prototype:o"],"tls.connect.prototype":["constructor:f"]},"tty":{"tty.isatty[[Function]]":["length:n","name:s","prototype:o"],"tty.isatty.prototype":["constructor:f"],"tty.ReadStream[[Function]]":["length:n","name:s","prototype:o"],"tty.ReadStream.prototype":["constructor:f"],"tty.WriteStream[[Function]]":["length:n","name:s","prototype:o"],"tty.WriteStream.prototype":["constructor:f"]},"url":{"url.Url[[Function]]":["length:n","name:s","prototype:o"],"url.Url.prototype":["constructor:f","format:f","parse:f","parseHost:f","resolve:f","resolveObject:f"],"url.parse[[Function]]":["length:n","name:s","prototype:o"],"url.parse.prototype":["constructor:f"],"url.resolve[[Function]]":["length:n","name:s","prototype:o"],"url.resolve.prototype":["constructor:f"],"url.resolveObject[[Function]]":["length:n","name:s","prototype:o"],"url.resolveObject.prototype":["constructor:f"],"url.format[[Function]]":["length:n","name:s","prototype:o"],"url.format.prototype":["constructor:f"],"url.URL[[Function]]":["canParse:f","createObjectURL:f","length:n","name:s","parse:f","prototype:o","revokeObjectURL:f"],"url.URL.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","hash:a","host:a","hostname:a","href:a","origin:a","password:a","pathname:a","port:a","protocol:a","search:a","searchParams:a","toJSON:f","toString:f","username:a"],"url.URLPattern[[Function]]":["length:n","name:s","prototype:o"],"url.URLPattern.prototype":["constructor:f","exec:f","hasRegExpGroups:a","hash:a","hostname:a","password:a","pathname:a","port:a","protocol:a","search:a","test:f","username:a"],"url.URLSearchParams[[Function]]":["length:n","name:s","prototype:o"],"url.URLSearchParams.prototype":["@@Symbol.iterator:f","@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","append:f","constructor:f","delete:f","entries:f","forEach:f","get:f","getAll:f","has:f","keys:f","set:f","size:a","sort:f","toString:f","values:f"],"url.domainToASCII[[Function]]":["length:n","name:s","prototype:o"],"url.domainToASCII.prototype":["constructor:f"],"url.domainToUnicode[[Function]]":["length:n","name:s","prototype:o"],"url.domainToUnicode.prototype":["constructor:f"],"url.pathToFileURL[[Function]]":["length:n","name:s","prototype:o"],"url.pathToFileURL.prototype":["constructor:f"],"url.fileURLToPath[[Function]]":["length:n","name:s","prototype:o"],"url.fileURLToPath.prototype":["constructor:f"],"url.fileURLToPathBuffer[[Function]]":["length:n","name:s","prototype:o"],"url.fileURLToPathBuffer.prototype":["constructor:f"],"url.urlToHttpOptions[[Function]]":["length:n","name:s","prototype:o"],"url.urlToHttpOptions.prototype":["constructor:f"]},"util":{"util._errnoException[[Function]]":["length:n","name:s","prototype:o"],"util._errnoException.prototype":["constructor:f"],"util._exceptionWithHostPort[[Function]]":["length:n","name:s","prototype:o"],"util._exceptionWithHostPort.prototype":["constructor:f"],"util._extend[[Function]]":["length:n","name:s","prototype:o"],"util._extend.prototype":["constructor:f"],"util.callbackify[[Function]]":["length:n","name:s","prototype:o"],"util.callbackify.prototype":["constructor:f"],"util.convertProcessSignalToExitCode[[Function]]":["length:n","name:s","prototype:o"],"util.convertProcessSignalToExitCode.prototype":["constructor:f"],"util.debug[[Function]]":["length:n","name:s","prototype:o"],"util.debug.prototype":["constructor:f"],"util.debuglog[[Function]]":["length:n","name:s","prototype:o"],"util.debuglog.prototype":["constructor:f"],"util.deprecate[[Function]]":["length:n","name:s","prototype:o"],"util.deprecate.prototype":["constructor:f"],"util.format[[Function]]":["length:n","name:s","prototype:o"],"util.format.prototype":["constructor:f"],"util.styleText[[Function]]":["length:n","name:s","prototype:o"],"util.styleText.prototype":["constructor:f"],"util.formatWithOptions[[Function]]":["length:n","name:s","prototype:o"],"util.formatWithOptions.prototype":["constructor:f"],"util.getCallSites[[Function]]":["length:n","name:s","prototype:o"],"util.getCallSites.prototype":["constructor:f"],"util.getSystemErrorMap[[Function]]":["length:n","name:s","prototype:o"],"util.getSystemErrorMap.prototype":["constructor:f"],"util.getSystemErrorName[[Function]]":["length:n","name:s","prototype:o"],"util.getSystemErrorName.prototype":["constructor:f"],"util.getSystemErrorMessage[[Function]]":["length:n","name:s","prototype:o"],"util.getSystemErrorMessage.prototype":["constructor:f"],"util.inherits[[Function]]":["length:n","name:s","prototype:o"],"util.inherits.prototype":["constructor:f"],"util.inspect[[Function]]":["colors:o","custom:y","defaultOptions:a","length:n","name:s","prototype:o","styles:o"],"util.inspect.prototype":["constructor:f"],"util.isArray[[Function]]":["length:n","name:s","prototype:o"],"util.isArray.prototype":["constructor:f"],"util.isDeepStrictEqual[[Function]]":["length:n","name:s"],"util.promisify[[Function]]":["custom:y","length:n","name:s","prototype:o"],"util.promisify.prototype":["constructor:f"],"util.stripVTControlCharacters[[Function]]":["length:n","name:s","prototype:o"],"util.stripVTControlCharacters.prototype":["constructor:f"],"util.toUSVString[[Function]]":["length:n","name:s"],"util.types":["isAnyArrayBuffer:f","isArgumentsObject:f","isArrayBuffer:f","isArrayBufferView:f","isAsyncFunction:f","isBigInt64Array:f","isBigIntObject:f","isBigUint64Array:f","isBooleanObject:f","isBoxedPrimitive:f","isCryptoKey:f","isDataView:f","isDate:f","isExternal:f","isFloat16Array:f","isFloat32Array:f","isFloat64Array:f","isGeneratorFunction:f","isGeneratorObject:f","isInt16Array:f","isInt32Array:f","isInt8Array:f","isKeyObject:f","isMap:f","isMapIterator:f","isModuleNamespaceObject:f","isNativeError:f","isNumberObject:f","isPromise:f","isProxy:f","isRegExp:f","isSet:f","isSetIterator:f","isSharedArrayBuffer:f","isStringObject:f","isSymbolObject:f","isTypedArray:f","isUint16Array:f","isUint32Array:f","isUint8Array:f","isUint8ClampedArray:f","isWeakMap:f","isWeakSet:f"],"util.parseEnv[[Function]]":["length:n","name:s","prototype:o"],"util.parseEnv.prototype":["constructor:f"],"util.parseArgs[[Function]]":["length:n","name:s"],"util.TextDecoder[[Function]]":["length:n","name:s","prototype:o"],"util.TextDecoder.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","decode:f","encoding:a","fatal:a","ignoreBOM:a"],"util.TextEncoder[[Function]]":["length:n","name:s","prototype:o"],"util.TextEncoder.prototype":["@@Symbol.toStringTag:s","@@nodejs.util.inspect.custom:f","constructor:f","encode:f","encodeInto:f","encoding:a"],"util.MIMEType[[Function]]":["length:n","name:s","prototype:o"],"util.MIMEType.prototype":["constructor:f","essence:a","params:a","subtype:a","toJSON:f","toString:f","type:a"],"util.MIMEParams[[Function]]":["length:n","name:s","prototype:o"],"util.MIMEParams.prototype":["@@Symbol.iterator:f","constructor:f","delete:f","entries:f","get:f","has:f","keys:f","set:f","toJSON:f","toString:f","values:f"],"util.diff[[Function]]":["length:n","name:s","prototype:o"],"util.diff.prototype":["constructor:f"],"util.setTraceSigInt[[Function]]":["length:n","name:s","prototype:o"],"util.setTraceSigInt.prototype":["constructor:f"]},"util/types":{"util/types.isArgumentsObject[[Function]]":["length:n","name:s"],"util/types.isArrayBuffer[[Function]]":["length:n","name:s"],"util/types.isAsyncFunction[[Function]]":["length:n","name:s"],"util/types.isBigIntObject[[Function]]":["length:n","name:s"],"util/types.isBooleanObject[[Function]]":["length:n","name:s"],"util/types.isDate[[Function]]":["length:n","name:s"],"util/types.isExternal[[Function]]":["length:n","name:s"],"util/types.isGeneratorFunction[[Function]]":["length:n","name:s"],"util/types.isGeneratorObject[[Function]]":["length:n","name:s"],"util/types.isMap[[Function]]":["length:n","name:s"],"util/types.isMapIterator[[Function]]":["length:n","name:s"],"util/types.isModuleNamespaceObject[[Function]]":["length:n","name:s"],"util/types.isNativeError[[Function]]":["length:n","name:s"],"util/types.isNumberObject[[Function]]":["length:n","name:s"],"util/types.isPromise[[Function]]":["length:n","name:s"],"util/types.isProxy[[Function]]":["length:n","name:s"],"util/types.isRegExp[[Function]]":["length:n","name:s"],"util/types.isSet[[Function]]":["length:n","name:s"],"util/types.isSetIterator[[Function]]":["length:n","name:s"],"util/types.isSharedArrayBuffer[[Function]]":["length:n","name:s"],"util/types.isStringObject[[Function]]":["length:n","name:s"],"util/types.isSymbolObject[[Function]]":["length:n","name:s"],"util/types.isWeakMap[[Function]]":["length:n","name:s"],"util/types.isWeakSet[[Function]]":["length:n","name:s"],"util/types.isAnyArrayBuffer[[Function]]":["length:n","name:s"],"util/types.isBoxedPrimitive[[Function]]":["length:n","name:s"],"util/types.isArrayBufferView[[Function]]":["length:n","name:s"],"util/types.isDataView[[Function]]":["length:n","name:s","prototype:o"],"util/types.isDataView.prototype":["constructor:f"],"util/types.isTypedArray[[Function]]":["length:n","name:s","prototype:o"],"util/types.isTypedArray.prototype":["constructor:f"],"util/types.isUint8Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isUint8Array.prototype":["constructor:f"],"util/types.isUint8ClampedArray[[Function]]":["length:n","name:s","prototype:o"],"util/types.isUint8ClampedArray.prototype":["constructor:f"],"util/types.isUint16Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isUint16Array.prototype":["constructor:f"],"util/types.isUint32Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isUint32Array.prototype":["constructor:f"],"util/types.isInt8Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isInt8Array.prototype":["constructor:f"],"util/types.isInt16Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isInt16Array.prototype":["constructor:f"],"util/types.isInt32Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isInt32Array.prototype":["constructor:f"],"util/types.isFloat16Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isFloat16Array.prototype":["constructor:f"],"util/types.isFloat32Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isFloat32Array.prototype":["constructor:f"],"util/types.isFloat64Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isFloat64Array.prototype":["constructor:f"],"util/types.isBigInt64Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isBigInt64Array.prototype":["constructor:f"],"util/types.isBigUint64Array[[Function]]":["length:n","name:s","prototype:o"],"util/types.isBigUint64Array.prototype":["constructor:f"],"util/types.isKeyObject[[Function]]":["length:n","name:s"],"util/types.isCryptoKey[[Function]]":["length:n","name:s"]},"v8":{"v8.cachedDataVersionTag[[Function]]":["length:n","name:s","prototype:o"],"v8.cachedDataVersionTag.prototype":["constructor:f"],"v8.getHeapSnapshot[[Function]]":["length:n","name:s","prototype:o"],"v8.getHeapSnapshot.prototype":["constructor:f"],"v8.getHeapStatistics[[Function]]":["length:n","name:s","prototype:o"],"v8.getHeapStatistics.prototype":["constructor:f"],"v8.getHeapSpaceStatistics[[Function]]":["length:n","name:s","prototype:o"],"v8.getHeapSpaceStatistics.prototype":["constructor:f"],"v8.getHeapCodeStatistics[[Function]]":["length:n","name:s","prototype:o"],"v8.getHeapCodeStatistics.prototype":["constructor:f"],"v8.getCppHeapStatistics[[Function]]":["length:n","name:s","prototype:o"],"v8.getCppHeapStatistics.prototype":["constructor:f"],"v8.setFlagsFromString[[Function]]":["length:n","name:s","prototype:o"],"v8.setFlagsFromString.prototype":["constructor:f"],"v8.Serializer[[Function]]":["length:n","name:s","prototype:o"],"v8.Serializer.prototype":["constructor:f"],"v8.Deserializer[[Function]]":["length:n","name:s","prototype:o"],"v8.Deserializer.prototype":["constructor:f"],"v8.DefaultSerializer[[Function]]":["length:n","name:s","prototype:o"],"v8.DefaultSerializer.prototype":["constructor:f"],"v8.DefaultDeserializer[[Function]]":["length:n","name:s","prototype:o"],"v8.DefaultDeserializer.prototype":["constructor:f"],"v8.deserialize[[Function]]":["length:n","name:s","prototype:o"],"v8.deserialize.prototype":["constructor:f"],"v8.takeCoverage[[Function]]":["length:n","name:s","prototype:o"],"v8.takeCoverage.prototype":["constructor:f"],"v8.stopCoverage[[Function]]":["length:n","name:s","prototype:o"],"v8.stopCoverage.prototype":["constructor:f"],"v8.serialize[[Function]]":["length:n","name:s","prototype:o"],"v8.serialize.prototype":["constructor:f"],"v8.writeHeapSnapshot[[Function]]":["length:n","name:s","prototype:o"],"v8.writeHeapSnapshot.prototype":["constructor:f"],"v8.promiseHooks":["createHook:f","onAfter:f","onBefore:f","onInit:f","onSettled:f"],"v8.queryObjects[[Function]]":["length:n","name:s","prototype:o"],"v8.queryObjects.prototype":["constructor:f"],"v8.startupSnapshot":["addDeserializeCallback:f","addSerializeCallback:f","isBuildingSnapshot:f","setDeserializeMainFunction:f"],"v8.setHeapSnapshotNearHeapLimit[[Function]]":["length:n","name:s","prototype:o"],"v8.setHeapSnapshotNearHeapLimit.prototype":["constructor:f"],"v8.GCProfiler[[Function]]":["length:n","name:s","prototype:o"],"v8.GCProfiler.prototype":["constructor:f"],"v8.isStringOneByteRepresentation[[Function]]":["length:n","name:s","prototype:o"],"v8.isStringOneByteRepresentation.prototype":["constructor:f"],"v8.startCpuProfile[[Function]]":["length:n","name:s","prototype:o"],"v8.startCpuProfile.prototype":["constructor:f"],"v8.startHeapProfile[[Function]]":["length:n","name:s","prototype:o"],"v8.startHeapProfile.prototype":["constructor:f"]},"vm":{"vm.Script[[Function]]":["length:n","name:s","prototype:o"],"vm.Script.prototype":["constructor:f","runInContext:f","runInNewContext:f","runInThisContext:f"],"vm.Script.prototype[[Prototype]]0":["constructor:f","createCachedData:f","runInContext:f"],"vm.createContext[[Function]]":["length:n","name:s","prototype:o"],"vm.createContext.prototype":["constructor:f"],"vm.createScript[[Function]]":["length:n","name:s","prototype:o"],"vm.createScript.prototype":["constructor:f"],"vm.runInContext[[Function]]":["length:n","name:s","prototype:o"],"vm.runInContext.prototype":["constructor:f"],"vm.runInNewContext[[Function]]":["length:n","name:s","prototype:o"],"vm.runInNewContext.prototype":["constructor:f"],"vm.runInThisContext[[Function]]":["length:n","name:s","prototype:o"],"vm.runInThisContext.prototype":["constructor:f"],"vm.isContext[[Function]]":["length:n","name:s","prototype:o"],"vm.isContext.prototype":["constructor:f"],"vm.compileFunction[[Function]]":["length:n","name:s","prototype:o"],"vm.compileFunction.prototype":["constructor:f"],"vm.measureMemory[[Function]]":["length:n","name:s","prototype:o"],"vm.measureMemory.prototype":["constructor:f"],"vm.constants":["DONT_CONTEXTIFY:y","USE_MAIN_CONTEXT_DEFAULT_LOADER:y"]},"wasi":{"wasi.WASI[[Function]]":["length:n","name:s","prototype:o"],"wasi.WASI.prototype":["constructor:f"]},"worker_threads":{"worker_threads.MessagePort[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.MessagePort.prototype":["@@handle_onclose:f","@@kCreateEvent:f","@@nodejs.util.inspect.custom:f","@@oninit:f","close:f","constructor:f","hasRef:f","onmessage:a","onmessageerror:a","postMessage:f","ref:f","start:f","unref:f"],"worker_threads.MessagePort.prototype[[Prototype]]0":["addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","off:f","on:f","once:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"worker_threads.MessagePort.prototype[[Prototype]]1":["@@Symbol.toStringTag:s","@@kCreateEvent:f","@@kNewListener:f","@@kRemoveListener:f","@@kRemoveWeakListenerHelper:f","@@nodejs.internal.kHybridDispatch:f","@@nodejs.util.inspect.custom:f","addEventListener:f","constructor:f","dispatchEvent:f","removeEventListener:f"],"worker_threads.MessageChannel[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.MessageChannel.prototype":["constructor:f"],"worker_threads.markAsUncloneable[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.markAsUncloneable.prototype":["constructor:f"],"worker_threads.markAsUntransferable[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.markAsUntransferable.prototype":["constructor:f"],"worker_threads.isMarkedAsUntransferable[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.isMarkedAsUntransferable.prototype":["constructor:f"],"worker_threads.moveMessagePortToContext[[Function]]":["length:n","name:s"],"worker_threads.receiveMessageOnPort[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.receiveMessageOnPort.prototype":["constructor:f"],"worker_threads.resourceLimits":["codeRangeSizeMb:n","maxOldGenerationSizeMb:n","maxYoungGenerationSizeMb:n","stackSizeMb:n"],"worker_threads.postMessageToThread[[Function]]":["length:n","name:s"],"worker_threads.Worker[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.Worker.prototype":["@@Symbol.asyncDispose:f","@@kDispose:f","@@kOnCouldNotSerializeErr:f","@@kOnErrorMessage:f","@@kOnExit:f","@@kOnMessage:f","constructor:f","cpuUsage:f","getHeapSnapshot:f","getHeapStatistics:f","postMessage:f","ref:f","resourceLimits:a","startCpuProfile:f","startHeapProfile:f","stderr:a","stdin:a","stdout:a","terminate:f","threadId:a","threadName:a","unref:f"],"worker_threads.Worker.prototype[[Prototype]]0":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"worker_threads.BroadcastChannel[[Function]]":["length:n","name:s","prototype:o"],"worker_threads.BroadcastChannel.prototype":["constructor:f"],"worker_threads.setEnvironmentData[[Function]]":["length:n","name:s"],"worker_threads.getEnvironmentData[[Function]]":["length:n","name:s"],"worker_threads.locks":["query:f","request:f"]},"zlib":{"zlib.crc32[[Function]]":["length:n","name:s","prototype:o"],"zlib.crc32.prototype":["constructor:f"],"zlib.Deflate[[Function]]":["length:n","name:s","prototype:o"],"zlib.Deflate.prototype":["constructor:f"],"zlib.Deflate.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.Deflate.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.Deflate.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.Deflate.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.Deflate.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.Deflate.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.Deflate.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.Inflate[[Function]]":["length:n","name:s","prototype:o"],"zlib.Inflate.prototype":["constructor:f"],"zlib.Inflate.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.Inflate.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.Inflate.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.Inflate.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.Inflate.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.Inflate.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.Inflate.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.Gzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.Gzip.prototype":["constructor:f"],"zlib.Gzip.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.Gzip.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.Gzip.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.Gzip.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.Gzip.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.Gzip.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.Gzip.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.Gunzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.Gunzip.prototype":["constructor:f"],"zlib.Gunzip.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.Gunzip.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.Gunzip.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.Gunzip.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.Gunzip.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.Gunzip.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.Gunzip.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.DeflateRaw[[Function]]":["length:n","name:s","prototype:o"],"zlib.DeflateRaw.prototype":["constructor:f"],"zlib.DeflateRaw.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.DeflateRaw.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.DeflateRaw.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.DeflateRaw.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.DeflateRaw.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.DeflateRaw.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.DeflateRaw.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.InflateRaw[[Function]]":["length:n","name:s","prototype:o"],"zlib.InflateRaw.prototype":["constructor:f"],"zlib.InflateRaw.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.InflateRaw.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.InflateRaw.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.InflateRaw.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.InflateRaw.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.InflateRaw.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.InflateRaw.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.Unzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.Unzip.prototype":["constructor:f"],"zlib.Unzip.prototype[[Prototype]]0":["constructor:f","params:f"],"zlib.Unzip.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.Unzip.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.Unzip.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.Unzip.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.Unzip.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.Unzip.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.BrotliCompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.BrotliCompress.prototype":["constructor:f"],"zlib.BrotliCompress.prototype[[Prototype]]0":["constructor:f"],"zlib.BrotliCompress.prototype[[Prototype]]1":["constructor:f","params:f"],"zlib.BrotliCompress.prototype[[Prototype]]2":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.BrotliCompress.prototype[[Prototype]]3":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.BrotliCompress.prototype[[Prototype]]4":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.BrotliCompress.prototype[[Prototype]]5":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.BrotliCompress.prototype[[Prototype]]6":["constructor:f","eventNames:f","pipe:f"],"zlib.BrotliCompress.prototype[[Prototype]]7":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.BrotliDecompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.BrotliDecompress.prototype":["constructor:f"],"zlib.BrotliDecompress.prototype[[Prototype]]0":["constructor:f"],"zlib.BrotliDecompress.prototype[[Prototype]]1":["constructor:f","params:f"],"zlib.BrotliDecompress.prototype[[Prototype]]2":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.BrotliDecompress.prototype[[Prototype]]3":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.BrotliDecompress.prototype[[Prototype]]4":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.BrotliDecompress.prototype[[Prototype]]5":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.BrotliDecompress.prototype[[Prototype]]6":["constructor:f","eventNames:f","pipe:f"],"zlib.BrotliDecompress.prototype[[Prototype]]7":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.ZstdCompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.ZstdCompress.prototype":["constructor:f"],"zlib.ZstdCompress.prototype[[Prototype]]0":["constructor:f"],"zlib.ZstdCompress.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.ZstdCompress.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.ZstdCompress.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.ZstdCompress.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.ZstdCompress.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.ZstdCompress.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.ZstdDecompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.ZstdDecompress.prototype":["constructor:f"],"zlib.ZstdDecompress.prototype[[Prototype]]0":["constructor:f"],"zlib.ZstdDecompress.prototype[[Prototype]]1":["_closed:a","_destroy:f","_final:f","_flush:f","_processChunk:f","_transform:f","close:f","constructor:f","flush:f","reset:f"],"zlib.ZstdDecompress.prototype[[Prototype]]2":["_final:f","_read:f","_transform:f","_write:f","constructor:f"],"zlib.ZstdDecompress.prototype[[Prototype]]3":["_write:f","_writev:l","constructor:f","cork:f","destroy:f","destroyed:a","end:f","setDefaultEncoding:f","uncork:f","writable:a","writableBuffer:a","writableCorked:a","writableEnded:a","writableFinished:a","writableHighWaterMark:a","writableLength:a","writableNeedDrain:a","writableObjectMode:a","write:f"],"zlib.ZstdDecompress.prototype[[Prototype]]4":["@@Stream.toAsyncStreamable:f","@@Symbol.asyncDispose:f","@@Symbol.asyncIterator:f","@@nodejs.rejection:f","_destroy:f","_read:f","_undestroy:f","addListener:f","closed:a","compose:f","constructor:f","destroy:f","destroyed:a","drop:f","errored:a","every:f","filter:f","find:f","flatMap:f","forEach:f","isPaused:f","iterator:f","map:f","off:f","on:f","pause:f","pipe:f","push:f","read:f","readable:a","readableAborted:a","readableBuffer:a","readableDidRead:a","readableEncoding:a","readableEnded:a","readableFlowing:a","readableHighWaterMark:a","readableLength:a","readableObjectMode:a","reduce:f","removeAllListeners:f","removeListener:f","resume:f","setEncoding:f","some:f","take:f","toArray:f","unpipe:f","unshift:f","wrap:f"],"zlib.ZstdDecompress.prototype[[Prototype]]5":["constructor:f","eventNames:f","pipe:f"],"zlib.ZstdDecompress.prototype[[Prototype]]6":["@@kCapture:b","_events:u","_eventsCount:n","_maxListeners:u","addListener:f","constructor:f","emit:f","eventNames:f","getMaxListeners:f","listenerCount:f","listeners:f","off:f","on:f","once:f","prependListener:f","prependOnceListener:f","rawListeners:f","removeAllListeners:f","removeListener:f","setMaxListeners:f"],"zlib.deflate[[Function]]":["length:n","name:s","prototype:o"],"zlib.deflate.prototype":["constructor:f"],"zlib.deflateSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.deflateSync.prototype":["constructor:f"],"zlib.gzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.gzip.prototype":["constructor:f"],"zlib.gzipSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.gzipSync.prototype":["constructor:f"],"zlib.deflateRaw[[Function]]":["length:n","name:s","prototype:o"],"zlib.deflateRaw.prototype":["constructor:f"],"zlib.deflateRawSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.deflateRawSync.prototype":["constructor:f"],"zlib.unzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.unzip.prototype":["constructor:f"],"zlib.unzipSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.unzipSync.prototype":["constructor:f"],"zlib.inflate[[Function]]":["length:n","name:s","prototype:o"],"zlib.inflate.prototype":["constructor:f"],"zlib.inflateSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.inflateSync.prototype":["constructor:f"],"zlib.gunzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.gunzip.prototype":["constructor:f"],"zlib.gunzipSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.gunzipSync.prototype":["constructor:f"],"zlib.inflateRaw[[Function]]":["length:n","name:s","prototype:o"],"zlib.inflateRaw.prototype":["constructor:f"],"zlib.inflateRawSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.inflateRawSync.prototype":["constructor:f"],"zlib.brotliCompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.brotliCompress.prototype":["constructor:f"],"zlib.brotliCompressSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.brotliCompressSync.prototype":["constructor:f"],"zlib.brotliDecompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.brotliDecompress.prototype":["constructor:f"],"zlib.brotliDecompressSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.brotliDecompressSync.prototype":["constructor:f"],"zlib.zstdCompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.zstdCompress.prototype":["constructor:f"],"zlib.zstdCompressSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.zstdCompressSync.prototype":["constructor:f"],"zlib.zstdDecompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.zstdDecompress.prototype":["constructor:f"],"zlib.zstdDecompressSync[[Function]]":["length:n","name:s","prototype:o"],"zlib.zstdDecompressSync.prototype":["constructor:f"],"zlib.createDeflate[[Function]]":["length:n","name:s","prototype:o"],"zlib.createDeflate.prototype":["constructor:f"],"zlib.createInflate[[Function]]":["length:n","name:s","prototype:o"],"zlib.createInflate.prototype":["constructor:f"],"zlib.createDeflateRaw[[Function]]":["length:n","name:s","prototype:o"],"zlib.createDeflateRaw.prototype":["constructor:f"],"zlib.createInflateRaw[[Function]]":["length:n","name:s","prototype:o"],"zlib.createInflateRaw.prototype":["constructor:f"],"zlib.createGzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.createGzip.prototype":["constructor:f"],"zlib.createGunzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.createGunzip.prototype":["constructor:f"],"zlib.createUnzip[[Function]]":["length:n","name:s","prototype:o"],"zlib.createUnzip.prototype":["constructor:f"],"zlib.createBrotliCompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.createBrotliCompress.prototype":["constructor:f"],"zlib.createBrotliDecompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.createBrotliDecompress.prototype":["constructor:f"],"zlib.createZstdCompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.createZstdCompress.prototype":["constructor:f"],"zlib.createZstdDecompress[[Function]]":["length:n","name:s","prototype:o"],"zlib.createZstdDecompress.prototype":["constructor:f"],"zlib.constants":[],"zlib.codes":["-1:s","-2:s","-3:s","-4:s","-5:s","-6:s","0:s","1:s","2:s","Z_BUF_ERROR:n","Z_DATA_ERROR:n","Z_ERRNO:n","Z_MEM_ERROR:n","Z_NEED_DICT:n","Z_OK:n","Z_STREAM_END:n","Z_STREAM_ERROR:n","Z_VERSION_ERROR:n"]}}) + +export const NODE_BUILTIN_GRAPH_FROM_26_8 = Object.freeze({"crypto":{"crypto.constants":["defaultCipherList:s","defaultCoreCipherList:s"]},"fs":{"fs.constants":[]},"fs/promises":{"fs/promises.constants":[]},"sys":{"sys.MIMEType[[Function]]":["length:n","name:s","parse:f","prototype:o"]},"util":{"util.MIMEType[[Function]]":["length:n","name:s","parse:f","prototype:o"]},"util/types":{"util/types.isKeyObject.prototype":["constructor:f"],"util/types.isKeyObject[[Function]]":["length:n","name:s","prototype:o"],"util/types.isCryptoKey[[Function]]":["length:n","name:s","prototype:o"],"util/types.isCryptoKey.prototype":["constructor:f"]},"zlib":{"zlib.ZipEntry[[Function]]":["length:n","name:s"],"zlib.ZipBuffer[[Function]]":["length:n","name:s"],"zlib.createZipArchiveSync[[Function]]":["length:n","name:s"],"zlib.createZipArchive[[Function]]":["length:n","name:s"],"zlib.ZipFile[[Function]]":["length:n","name:s"],"zlib.setMaxZipContentSize[[Function]]":["length:n","name:s"],"zlib.getMaxZipContentSize[[Function]]":["length:n","name:s"],"zlib.zipFiles[[Function]]":["length:n","name:s"]}}) + +export const NODE_BUILTIN_GRAPH_FROM_26_9 = Object.freeze({"async_hooks":{"async_hooks.asyncWrapProviders":["ARGON2REQUEST:n","BLOBREADER:n","CHECKPRIMEREQUEST:n","CIPHERREQUEST:n","DERIVEBITSREQUEST:n","DIRHANDLE:n","DNSCHANNEL:n","DTLS_ENDPOINT:n","DTLS_SESSION:n","ELDHISTOGRAM:n","FILEHANDLE:n","FILEHANDLECLOSEREQ:n","FSEVENTWRAP:n","FSREQCALLBACK:n","FSREQPROMISE:n","GETADDRINFOREQWRAP:n","GETNAMEINFOREQWRAP:n","HASHREQUEST:n","HEAPSNAPSHOT:n","HTTP2PING:n","HTTP2SESSION:n","HTTP2SETTINGS:n","HTTP2STREAM:n","HTTPCLIENTREQUEST:n","HTTPINCOMINGMESSAGE:n","JSSTREAM:n","JSUDPWRAP:n","KEYEXPORTREQUEST:n","KEYGENREQUEST:n","KEYPAIRGENREQUEST:n","LOCKS:n","MESSAGEPORT:n","NONE:n","PBKDF2REQUEST:n","PIPECONNECTWRAP:n","PIPESERVERWRAP:n","PIPEWRAP:n","PROCESSWRAP:n","PROMISE:n","QUERYWRAP:n","QUIC_ENDPOINT:n","QUIC_LOGSTREAM:n","QUIC_SESSION:n","QUIC_STREAM:n","QUIC_UDP:n","RANDOMBYTESREQUEST:n","RANDOMPRIMEREQUEST:n","SCRYPTREQUEST:n","SHUTDOWNWRAP:n","SIGINTWATCHDOG:n","SIGNALWRAP:n","SIGNREQUEST:n","STATWATCHER:n","STREAMPIPE:n","TCPCONNECTWRAP:n","TCPSERVERWRAP:n","TCPWRAP:n","TLSWRAP:n","TTYWRAP:n","UDPSENDWRAP:n","UDPWRAP:n","VERIFYREQUEST:n","WORKER:n","WORKERCPUPROFILE:n","WORKERCPUUSAGE:n","WORKERHEAPPROFILE:n","WORKERHEAPSNAPSHOT:n","WORKERHEAPSTATISTICS:n","WRITEWRAP:n","ZLIB:n"]},"crypto":{"crypto.createMac[[Function]]":["length:n","name:s","prototype:o"],"crypto.getMacs[[Function]]":["length:n","name:s"],"crypto.X509Certificate.prototype":["@@nodejs.util.inspect.custom:f","ca:a","checkEmail:f","checkHost:f","checkIP:f","checkIssued:f","checkPrivateKey:f","constructor:f","fingerprint256:a","fingerprint512:a","fingerprint:a","infoAccess:a","issuer:a","issuerCertificate:a","keyUsage:a","publicKey:a","raw:a","serialNumber:a","signatureAlgorithm:a","signatureAlgorithmOid:a","subject:a","subjectAltName:a","toJSON:f","toLegacyObject:f","toString:f","validFrom:a","validFromDate:a","validTo:a","validToDate:a","verify:f"],"crypto.createMac.prototype":["constructor:f"]},"perf_hooks":{"perf_hooks.importHistogram.prototype":["constructor:f"],"perf_hooks.importHistogram[[Function]]":["length:n","name:s","prototype:o"]},"process":{"process.features":["cached_builtins:a","debug:b","dtls:a","inspector:b","ipv6:b","openssl_is_boringssl:b","quic:a","require_module:a","tls:b","tls_alpn:b","tls_ocsp:b","tls_sni:b","typescript:a","uv:b"]},"v8":{"v8.setHeapProfileNearHeapLimit.prototype":["constructor:f"],"v8.setHeapProfileNearHeapLimit[[Function]]":["length:n","name:s","prototype:o"]}}) + +export const NODE_BUILTIN_GRAPH_OPTIONAL_PATHS = Object.freeze(["process.allowedNodeEnvironmentFlags","process.allowedNodeEnvironmentFlags[[Prototype]]0"]) + +export const NODE_BUILTIN_SURFACE_PLATFORM = Object.freeze({"linux":{},"darwin":{"fs":[["Dir:f","Dirent:f","FileReadStream:a","FileWriteStream:a","ReadStream:a","Stats:f","Utf8Stream:a","WriteStream:a","_toUnixTimestamp:f","access:f","accessSync:f","appendFile:f","appendFileSync:f","chmod:f","chmodSync:f","chown:f","chownSync:f","close:f","closeSync:f","constants:o","copyFile:f","copyFileSync:f","cp:f","cpSync:f","createReadStream:f","createWriteStream:f","exists:f","existsSync:f","fchmod:f","fchmodSync:f","fchown:f","fchownSync:f","fdatasync:f","fdatasyncSync:f","fstat:f","fstatSync:f","fsync:f","fsyncSync:f","ftruncate:f","ftruncateSync:f","futimes:f","futimesSync:f","glob:f","globSync:f","lchmod:f","lchmodSync:f","lchown:f","lchownSync:f","link:f","linkSync:f","lstat:f","lstatSync:f","lutimes:f","lutimesSync:f","mkdir:f","mkdirSync:f","mkdtemp:f","mkdtempDisposableSync:f","mkdtempSync:f","open:f","openAsBlob:f","openSync:f","opendir:f","opendirSync:f","promises:a","read:f","readFile:f","readFileSync:f","readSync:f","readdir:f","readdirSync:f","readlink:f","readlinkSync:f","readv:f","readvSync:f","realpath:f","realpathSync:f","rename:f","renameSync:f","rm:f","rmSync:f","rmdir:f","rmdirSync:f","stat:f","statSync:f","statfs:f","statfsSync:f","symlink:f","symlinkSync:f","truncate:f","truncateSync:f","unlink:f","unlinkSync:f","unwatchFile:f","utimes:f","utimesSync:f","watch:f","watchFile:f","write:f","writeFile:f","writeFileSync:f","writeSync:f","writev:f","writevSync:f"],["@@Symbol.toStringTag:s","Dir:f","Dirent:f","FileReadStream:f","FileWriteStream:f","ReadStream:f","Stats:f","Utf8Stream:f","WriteStream:f","_toUnixTimestamp:f","access:f","accessSync:f","appendFile:f","appendFileSync:f","chmod:f","chmodSync:f","chown:f","chownSync:f","close:f","closeSync:f","constants:o","copyFile:f","copyFileSync:f","cp:f","cpSync:f","createReadStream:f","createWriteStream:f","default:o","exists:f","existsSync:f","fchmod:f","fchmodSync:f","fchown:f","fchownSync:f","fdatasync:f","fdatasyncSync:f","fstat:f","fstatSync:f","fsync:f","fsyncSync:f","ftruncate:f","ftruncateSync:f","futimes:f","futimesSync:f","glob:f","globSync:f","lchmod:f","lchmodSync:f","lchown:f","lchownSync:f","link:f","linkSync:f","lstat:f","lstatSync:f","lutimes:f","lutimesSync:f","mkdir:f","mkdirSync:f","mkdtemp:f","mkdtempDisposableSync:f","mkdtempSync:f","open:f","openAsBlob:f","openSync:f","opendir:f","opendirSync:f","promises:f","read:f","readFile:f","readFileSync:f","readSync:f","readdir:f","readdirSync:f","readlink:f","readlinkSync:f","readv:f","readvSync:f","realpath:f","realpathSync:f","rename:f","renameSync:f","rm:f","rmSync:f","rmdir:f","rmdirSync:f","stat:f","statSync:f","statfs:f","statfsSync:f","symlink:f","symlinkSync:f","truncate:f","truncateSync:f","unlink:f","unlinkSync:f","unwatchFile:f","utimes:f","utimesSync:f","watch:f","watchFile:f","write:f","writeFile:f","writeFileSync:f","writeSync:f","writev:f","writevSync:f"]]},"win32":{"process":[["@@Symbol.toStringTag:s","@@kCapture:b","@@shapeMode:b","_eval:s","_events:o","_eventsCount:n","_exiting:a","_fatalException:f","_getActiveHandles:f","_getActiveRequests:f","_kill:f","_linkedBinding:f","_maxListeners:u","_preload_modules:o","_rawDebug:f","_tickCallback:f","abort:f","addUncaughtExceptionCaptureCallback:f","allowedNodeEnvironmentFlags:a|o","arch:s","argv0:s","argv:o","availableMemory:f","binding:f","chdir:f","config:o","constrainedMemory:f","cpuUsage:f","cwd:f","debugPort:n","dlopen:f","domain:a","emitWarning:f","env:o","execArgv:o","execPath:s","execve:f","exit:f","exitCode:a","features:o","finalization:a","getActiveResourcesInfo:f","getBuiltinModule:f","hasUncaughtExceptionCaptureCallback:f","hrtime:f","kill:f","loadEnvFile:f","memoryUsage:f","moduleLoadList:o","nextTick:f","openStdin:f","permission:o","pid:n","platform:s","ppid:n","reallyExit:f","ref:f","release:o","report:a","resourceUsage:f","setSourceMapsEnabled:f","setUncaughtExceptionCaptureCallback:f","sourceMapsEnabled:a","stderr:a","stdin:a","stdout:a","threadCpuUsage:f","title:s","umask:f","unref:f","uptime:f","version:s","versions:o"],["@@Symbol.toStringTag:s","_eval:s","_events:o","_eventsCount:n","_exiting:b","_fatalException:f","_getActiveHandles:f","_getActiveRequests:f","_kill:f","_linkedBinding:f","_maxListeners:u","_preload_modules:o","_rawDebug:f","_tickCallback:f","abort:f","addUncaughtExceptionCaptureCallback:f","allowedNodeEnvironmentFlags:o","arch:s","argv0:s","argv:o","availableMemory:f","binding:f","chdir:f","config:o","constrainedMemory:f","cpuUsage:f","cwd:f","debugPort:n","default:o","dlopen:f","domain:l","emitWarning:f","env:o","execArgv:o","execPath:s","execve:f","exit:f","exitCode:u","features:o","finalization:o","getActiveResourcesInfo:f","getBuiltinModule:f","hasUncaughtExceptionCaptureCallback:f","hrtime:f","kill:f","loadEnvFile:f","memoryUsage:f","moduleLoadList:o","nextTick:f","openStdin:f","permission:o","pid:n","platform:s","ppid:n","reallyExit:f","ref:f","release:o","report:o","resourceUsage:f","setSourceMapsEnabled:f","setUncaughtExceptionCaptureCallback:f","sourceMapsEnabled:b","stderr:o","stdin:o","stdout:o","threadCpuUsage:f","title:s","umask:f","unref:f","uptime:f","version:s","versions:o"]]}}) + +export const NODE_BUILTIN_GRAPH_PLATFORM = Object.freeze({"linux":{},"darwin":{"fs":{"fs.lchmod[[Function]]":["length:n","name:s","prototype:o"],"fs.lchmod.prototype":["constructor:f"],"fs.lchmodSync[[Function]]":["length:n","name:s","prototype:o"],"fs.lchmodSync.prototype":["constructor:f"]}},"win32":{"process":{"process.initgroups[[Function]]":null,"process.initgroups.prototype":null,"process.setgroups[[Function]]":null,"process.setgroups.prototype":null,"process.setegid[[Function]]":null,"process.setegid.prototype":null,"process.seteuid[[Function]]":null,"process.seteuid.prototype":null,"process.setgid[[Function]]":null,"process.setgid.prototype":null,"process.setuid[[Function]]":null,"process.setuid.prototype":null,"process.release":["headersUrl:s","libUrl:s","name:s","sourceUrl:s"]}}}) diff --git a/src/session-bootstrap.js b/src/session-bootstrap.js index d14cff7..fbae0ee 100644 --- a/src/session-bootstrap.js +++ b/src/session-bootstrap.js @@ -1,5 +1,5 @@ 'use strict' -;(function trustedBootstrap() { +;(function trustedBootstrap(nodeCapabilityPolicy) { const cryptoBuiltin = require('node:crypto') const { createHmac, generateKeySync } = cryptoBuiltin @@ -30,6 +30,7 @@ const tlsBuiltin = require('node:tls') const ttyBuiltin = require('node:tty') const v8Builtin = require('node:v8') const wasiBuiltin = require('node:wasi') +const zlibBuiltin = require('node:zlib') const utilTypesBuiltin = require('node:util/types') const workerThreadsBuiltin = require('node:worker_threads') let ffiBuiltin @@ -49,8 +50,11 @@ const networkAliasBuiltins = [ require('_tls_wrap') ] const { deserialize: v8Deserialize, serialize: v8Serialize } = v8Builtin +const moduleBuiltinModules = moduleBuiltin.builtinModules +const moduleIsBuiltin = moduleBuiltin.isBuiltin const moduleLoad = moduleBuiltin._load const moduleNodeModulePaths = moduleBuiltin._nodeModulePaths +const moduleRegisterHooks = moduleBuiltin.registerHooks const moduleResolveLookupPaths = moduleBuiltin._resolveLookupPaths const processGetBuiltinModule = processBuiltin.getBuiltinModule const { stripTypeScriptTypes } = moduleBuiltin @@ -98,6 +102,7 @@ const weakSetDelete = WeakSet.prototype.delete const arrayPush = Array.prototype.push const arrayPop = Array.prototype.pop const arrayJoin = Array.prototype.join +const arraySort = Array.prototype.sort const arraySplice = Array.prototype.splice const mapGet = Map.prototype.get const mapSet = Map.prototype.set @@ -115,14 +120,15 @@ const regexpSource = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source') const sharedByteLength = typeof SharedArrayBuffer === 'undefined' ? undefined : Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength').get +const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype) const typedArrayBuffer = Object.getOwnPropertyDescriptor( - Object.getPrototypeOf(Uint8Array.prototype), + typedArrayPrototype, 'buffer' ).get const dataViewPrototype = DataView.prototype const dataViewBuffer = Object.getOwnPropertyDescriptor(dataViewPrototype, 'buffer').get const typedArrayLength = Object.getOwnPropertyDescriptor( - Object.getPrototypeOf(Uint8Array.prototype), + typedArrayPrototype, 'length' ).get const typedArrayByteLength = Object.getOwnPropertyDescriptor( @@ -140,6 +146,14 @@ const objectGetPrototypeOf = Object.getPrototypeOf const objectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor const objectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors const objectHasOwn = Object.hasOwn +// Node's synchronous module hooks use async-context internals that read the +// inherited typed-array length. Keep guest mutation from poisoning the trusted +// resolver after it has been installed. +objectDefineProperty(typedArrayPrototype, 'length', { + configurable: false, + enumerable: false, + get: typedArrayLength +}) const objectIsExtensible = Object.isExtensible const objectPrototype = Object.prototype const nativeErrorStackDescriptor = objectGetOwnPropertyDescriptor(new SafeError(), 'stack') @@ -263,6 +277,7 @@ const AWAIT_PROMISE_CONSTRUCTOR_DESCRIPTOR = objectFreeze({ }) const arrayPrototype = Array.prototype const arrayBufferPrototype = ArrayBuffer.prototype +const functionPrototype = Function.prototype const datePrototype = Date.prototype const regexpPrototype = RegExp.prototype const errorPrototype = SafeError.prototype @@ -282,6 +297,11 @@ const nativeErrorPrototypeNames = new Map([ ]) const mapPrototype = Map.prototype const setPrototype = Set.prototype +const weakMapPrototype = WeakMap.prototype +const weakSetPrototype = WeakSet.prototype +const sharedArrayBufferPrototype = typeof SharedArrayBuffer === 'undefined' + ? undefined + : SharedArrayBuffer.prototype const allowedViewPrototypes = new Set([ dataViewPrototype, Int8Array.prototype, @@ -300,8 +320,11 @@ const allowedViewPrototypes = new Set([ const stringSlice = String.prototype.slice const stringSplit = String.prototype.split const stringIndexOf = String.prototype.indexOf +const stringLastIndexOf = String.prototype.lastIndexOf const stringCharCodeAt = String.prototype.charCodeAt const stringPadStart = String.prototype.padStart +const symbolDescription = Object.getOwnPropertyDescriptor(Symbol.prototype, 'description').get +const symbolKeyFor = Symbol.keyFor const numberToString = Number.prototype.toString const bufferByteLength = Buffer.byteLength const bufferFrom = Buffer.from @@ -341,6 +364,124 @@ function ownDataValue(value, key) { return descriptor?.value } +function freezeTrustedCapabilityPolicy(value) { + if (value === null || typeof value !== 'object' || + reflectApply(isProxy, utilTypesBuiltin, [value])) { + throw new SafeError('Invalid Node capability policy') + } + const keys = reflectOwnKeys(value) + for (let index = 0; index < keys.length; index++) { + const descriptor = ownDataDescriptor(value, keys[index]) + if (!descriptor) throw new SafeError('Invalid Node capability policy property') + const entry = descriptor.value + if (entry === null) continue + if (typeof entry === 'object') freezeTrustedCapabilityPolicy(entry) + else if (typeof entry !== 'string' && typeof entry !== 'number' && + typeof entry !== 'boolean') { + throw new SafeError('Invalid Node capability policy value') + } + } + return objectFreeze(value) +} + +function policyArray(value, label) { + if (!reflectApply(arrayIsArray, undefined, [value])) { + throw new SafeError('Invalid Node capability policy ' + label) + } + let previous + for (let index = 0; index < value.length; index++) { + const descriptor = ownDataDescriptor(value, index) + if (!descriptor || typeof descriptor.value !== 'string' || + (previous !== undefined && previous >= descriptor.value)) { + throw new SafeError('Invalid Node capability policy ' + label) + } + previous = descriptor.value + } + return value +} + +function prepareNodeCapabilityPolicy() { + freezeTrustedCapabilityPolicy(nodeCapabilityPolicy) + const graphBase = ownDataValue(nodeCapabilityPolicy, 'graphBase') + const graphFrom26_8 = ownDataValue(nodeCapabilityPolicy, 'graphFrom26_8') + const graphFrom26_9 = ownDataValue(nodeCapabilityPolicy, 'graphFrom26_9') + const graphOptionalPaths = ownDataValue(nodeCapabilityPolicy, 'graphOptionalPaths') + const graphPlatforms = ownDataValue(nodeCapabilityPolicy, 'graphPlatform') + const policy = ownDataValue(nodeCapabilityPolicy, 'policy') + const profiles = ownDataValue(nodeCapabilityPolicy, 'profiles') + const surfaceBase = ownDataValue(nodeCapabilityPolicy, 'surfaceBase') + const surfaceFrom26_8 = ownDataValue(nodeCapabilityPolicy, 'surfaceFrom26_8') + const surfaceFrom26_9 = ownDataValue(nodeCapabilityPolicy, 'surfaceFrom26_9') + const surfacePlatforms = ownDataValue(nodeCapabilityPolicy, 'surfacePlatform') + if (!graphBase || !graphFrom26_8 || !graphFrom26_9 || !graphOptionalPaths || + !graphPlatforms || !policy || !profiles || + !surfaceBase || !surfaceFrom26_8 || !surfaceFrom26_9 || !surfacePlatforms) { + throw new SafeError('Incomplete Node capability policy') + } + + const dispositions = new Map() + const surfacedIds = [] + for (const disposition of ['allowed', 'attenuated', 'modeDependent', 'denied']) { + const ids = policyArray(ownDataValue(policy, disposition), disposition) + for (let index = 0; index < ids.length; index++) { + const id = ids[index] + if (reflectApply(mapGet, dispositions, [id]) !== undefined) { + throw new SafeError('Duplicate Node capability policy entry') + } + reflectApply(mapSet, dispositions, [id, disposition]) + if (disposition !== 'denied') reflectApply(arrayPush, surfacedIds, [id]) + } + } + const optionalDenied = policyArray( + ownDataValue(policy, 'optionalDenied'), + 'optionalDenied' + ) + for (let index = 0; index < optionalDenied.length; index++) { + const id = optionalDenied[index] + if (reflectApply(mapGet, dispositions, [id]) !== undefined) { + throw new SafeError('Duplicate optional Node capability policy entry') + } + reflectApply(mapSet, dispositions, [id, 'denied']) + } + reflectApply(arraySort, surfacedIds, []) + + const versions = ownDataValue(processBuiltin, 'versions') + const nodeVersion = ownDataValue(versions, 'node') + if (typeof nodeVersion !== 'string') throw new SafeError('Invalid Node version metadata') + const versionParts = reflectApply(stringSplit, nodeVersion, ['.']) + const minor = SafeNumber(versionParts[1]) + if (!numberIsSafeInteger(minor)) throw new SafeError('Invalid Node version metadata') + const platform = ownDataValue(processBuiltin, 'platform') + const graphPlatform = ownDataValue(graphPlatforms, platform) + const surfacePlatform = ownDataValue(surfacePlatforms, platform) + if (!graphPlatform || !surfacePlatform) { + throw new SafeError('Unsupported Node capability platform') + } + const profile = policyArray( + ownDataValue(profiles, minor >= 9 ? 'from26_9' : 'before26_9'), + 'runtime profile' + ) + + return objectFreeze({ + dispositions, + graphBase, + graphFrom26_8, + graphFrom26_9, + graphOptionalPaths: policyArray(graphOptionalPaths, 'optional graph paths'), + graphPlatform, + profile, + surfacedIds: objectFreeze(surfacedIds), + surfaceBase, + surfaceFrom26_8, + surfaceFrom26_9, + surfacePlatform, + use26_8Surface: minor >= 8, + use26_9Surface: minor >= 9 + }) +} + +const preparedNodeCapabilityPolicy = prepareNodeCapabilityPolicy() + function hasOriginalOwnDescriptor(value, key, originalDescriptor) { const descriptor = ownPropertyDescriptor(value, key) if (descriptor === undefined || originalDescriptor === undefined) { @@ -372,6 +513,7 @@ let diagnosticSequence = 0 let diagnosticRecords = 0 let diagnosticBytes = 0 let handler +let nodeCapabilityHook const controlPromises = new SafeWeakSet() const promiseSettlementGuardedValues = new SafeWeakSet() let processing = SafePromise.resolve() @@ -720,6 +862,12 @@ function replaceProperty(target, name, value) { writable: false }) } + const replacement = objectGetOwnPropertyDescriptor(target, name) + if (!replacement || + !reflectApply(objectHasOwn, undefined, [replacement, 'value']) || + replacement.value !== value || replacement.writable || replacement.configurable) { + throw new SafeError('Failed to replace ' + name) + } } function replaceAndVerifyDataProperty(target, name, value) { @@ -947,6 +1095,403 @@ function hardenFileSystemForModuleLoading() { denyFunctions(fsPromisesBuiltin, 'node:fs/promises') } +function builtinDisposition(request) { + if (typeof request !== 'string') return undefined + let disposition = reflectApply(mapGet, preparedNodeCapabilityPolicy.dispositions, [request]) + if (disposition === undefined && reflectApply(stringIndexOf, request, ['node:']) === 0) { + disposition = reflectApply( + mapGet, + preparedNodeCapabilityPolicy.dispositions, + [reflectApply(stringSlice, request, [5])] + ) + } + return disposition +} + +function enforceBuiltinPolicy(request) { + if (typeof request !== 'string') return + const recognized = reflectApply(moduleIsBuiltin, moduleBuiltin, [request]) + const disposition = builtinDisposition(request) + if (!recognized && disposition === undefined) return + if (disposition === undefined || disposition === 'denied' || + (disposition === 'modeDependent' && !workerData.localModule)) { + return sandboxDenied(request) + } +} + +function signatureKind(value) { + if (value === null) return 'l' + if (typeof value === 'bigint') return 'i' + if (typeof value === 'boolean') return 'b' + if (typeof value === 'function') return 'f' + if (typeof value === 'number') return 'n' + if (typeof value === 'object') return 'o' + if (typeof value === 'string') return 's' + if (typeof value === 'symbol') return 'y' + if (typeof value === 'undefined') return 'u' + throw new SafeError('Unsupported Node capability descriptor') +} + +function capabilityKeyName(key) { + if (typeof key === 'string') return key + const globalName = reflectApply(symbolKeyFor, undefined, [key]) + const description = globalName === undefined + ? reflectApply(symbolDescription, key, []) + : globalName + return '@@' + (description === undefined ? '' : description) +} + +function capabilitySurfaceSignature(value, omitNumericConstants = false) { + if (value === null || (typeof value !== 'object' && typeof value !== 'function') || + reflectApply(isProxy, utilTypesBuiltin, [value])) { + throw new SafeError('Invalid Node capability export') + } + const descriptors = objectGetOwnPropertyDescriptors(value) + const keys = reflectOwnKeys(value) + const result = [] + for (let index = 0; index < keys.length; index++) { + const key = keys[index] + const name = capabilityKeyName(key) + const descriptor = ownDataValue(descriptors, key) + if (!descriptor) throw new SafeError('Invalid Node capability descriptor') + const hasValue = reflectApply(objectHasOwn, undefined, [descriptor, 'value']) + if (omitNumericConstants && hasValue && typeof descriptor.value === 'number') continue + const kind = hasValue ? signatureKind(descriptor.value) : 'a' + reflectApply(arrayPush, result, [name + ':' + kind]) + } + reflectApply(arraySort, result, []) + return result +} + +function capabilitySignatureMatches(expected, actual) { + if (expected === actual) return true + const expectedSeparator = reflectApply(stringLastIndexOf, expected, [':']) + const actualSeparator = reflectApply(stringLastIndexOf, actual, [':']) + if (expectedSeparator < 0 || actualSeparator < 0 || + reflectApply(stringSlice, expected, [0, expectedSeparator]) !== + reflectApply(stringSlice, actual, [0, actualSeparator])) { + return false + } + const expectedKinds = reflectApply( + stringSplit, + reflectApply(stringSlice, expected, [expectedSeparator + 1]), + ['|'] + ) + const actualKind = reflectApply(stringSlice, actual, [actualSeparator + 1]) + for (let index = 0; index < expectedKinds.length; index++) { + if (expectedKinds[index] === actualKind) return true + } + return false +} + +function verifyCapabilitySurface(id, side, value) { + const platformPair = ownDataValue(preparedNodeCapabilityPolicy.surfacePlatform, id) + const expectedPair = platformPair === undefined + ? ownDataValue(preparedNodeCapabilityPolicy.surfaceBase, id) + : platformPair + if (!reflectApply(arrayIsArray, undefined, [expectedPair])) { + throw new SafeError('Missing Node capability surface policy') + } + const expectedBase = ownDataValue(expectedPair, side) + if (!reflectApply(arrayIsArray, undefined, [expectedBase])) { + throw new SafeError('Invalid Node capability surface policy') + } + const expected = [] + for (let index = 0; index < expectedBase.length; index++) { + reflectApply(arrayPush, expected, [ownDataValue(expectedBase, index)]) + } + for (const additionsPolicy of [ + preparedNodeCapabilityPolicy.use26_8Surface + ? preparedNodeCapabilityPolicy.surfaceFrom26_8 + : undefined, + preparedNodeCapabilityPolicy.use26_9Surface + ? preparedNodeCapabilityPolicy.surfaceFrom26_9 + : undefined + ]) { + if (additionsPolicy === undefined) continue + const additionPair = ownDataValue(additionsPolicy, id) + if (additionPair === undefined) continue + const additions = ownDataValue(additionPair, side) + if (!reflectApply(arrayIsArray, undefined, [additions])) { + throw new SafeError('Invalid Node capability surface addition') + } + for (let index = 0; index < additions.length; index++) { + reflectApply(arrayPush, expected, [ownDataValue(additions, index)]) + } + } + reflectApply(arraySort, expected, []) + const actual = capabilitySurfaceSignature(value, id === 'constants') + if (actual.length !== expected.length) { + throw new SafeError('Unreviewed Node capability surface: ' + id) + } + for (let index = 0; index < actual.length; index++) { + if (!capabilitySignatureMatches(expected[index], actual[index])) { + throw new SafeError('Unreviewed Node capability surface: ' + id) + } + } +} + +async function verifyNodeCapabilityPolicy() { + if (!reflectApply(arrayIsArray, undefined, [moduleBuiltinModules])) { + throw new SafeError('Node builtin inventory is unavailable') + } + const actualIds = [] + for (let index = 0; index < moduleBuiltinModules.length; index++) { + const descriptor = ownDataDescriptor(moduleBuiltinModules, index) + if (!descriptor || typeof descriptor.value !== 'string' || + builtinDisposition(descriptor.value) === undefined) { + throw new SafeError('Unreviewed Node builtin module') + } + reflectApply(arrayPush, actualIds, [descriptor.value]) + } + reflectApply(arraySort, actualIds, []) + const expectedIds = preparedNodeCapabilityPolicy.profile + if (actualIds.length !== expectedIds.length) { + throw new SafeError('Unreviewed Node builtin module inventory') + } + for (let index = 0; index < actualIds.length; index++) { + if (actualIds[index] !== expectedIds[index]) { + throw new SafeError('Unreviewed Node builtin module inventory') + } + } + + const ids = preparedNodeCapabilityPolicy.surfacedIds + for (let index = 0; index < ids.length; index++) { + const id = ids[index] + const specifier = reflectApply(stringIndexOf, id, ['node:']) === 0 + ? id + : 'node:' + id + const commonjs = reflectApply(moduleLoad, moduleBuiltin, [specifier]) + verifyCapabilitySurface(id, 0, commonjs) + } +} + +async function verifyNodeCapabilityNamespaces() { + const ids = preparedNodeCapabilityPolicy.surfacedIds + for (let index = 0; index < ids.length; index++) { + const id = ids[index] + const specifier = reflectApply(stringIndexOf, id, ['node:']) === 0 + ? id + : 'node:' + id + const namespace = await import(specifier) + verifyCapabilitySurface(id, 1, namespace) + } +} + +function isCapabilityGraphExcludedObject(value) { + if (reflectApply(arrayIsArray, undefined, [value]) || + reflectApply(arrayBufferIsView, undefined, [value])) return true + const prototype = objectGetPrototypeOf(value) + return prototype === mapPrototype || prototype === setPrototype || + prototype === weakMapPrototype || prototype === weakSetPrototype || + prototype === datePrototype || prototype === regexpPrototype || + prototype === arrayBufferPrototype || prototype === sharedArrayBufferPrototype || + prototype === dataViewPrototype +} + +function isCapabilityGraphStopPrototype(value) { + if (value === objectPrototype || value === functionPrototype || + value === arrayPrototype || value === mapPrototype || value === setPrototype || + value === weakMapPrototype || value === weakSetPrototype || + value === promisePrototype || value === datePrototype || value === regexpPrototype || + value === errorPrototype || value === arrayBufferPrototype || + value === sharedArrayBufferPrototype || value === dataViewPrototype) return true + return reflectApply(setHas, allowedViewPrototypes, [value]) +} + +function defineCapabilityGraphEntry(graph, path, value, budget) { + budget.nodes++ + if (budget.nodes > 4096) throw new SafeError('Node capability graph exceeds node budget') + const signature = capabilitySurfaceSignature( + value, + reflectApply(stringSlice, path, [-10]) === '.constants' + ) + budget.properties += signature.length + if (budget.properties > 50_000) { + throw new SafeError('Node capability graph exceeds property budget') + } + objectDefineProperty(graph, path, { + configurable: false, + enumerable: true, + value: signature, + writable: false + }) +} + +function inspectCapabilityGraphObject(value, path, graph, budget) { + if (path === 'process.env') return + if (value === null || typeof value !== 'object' || + isCapabilityGraphExcludedObject(value) || + reflectApply(isProxy, utilTypesBuiltin, [value])) return + defineCapabilityGraphEntry(graph, path, value, budget) + let prototype = objectGetPrototypeOf(value) + let level = 0 + while (prototype && !isCapabilityGraphStopPrototype(prototype)) { + if (level >= 12) throw new SafeError('Node capability prototype chain is too deep') + defineCapabilityGraphEntry( + graph, + path + '[[Prototype]]' + reflectApply(numberToString, level, []), + prototype, + budget + ) + prototype = objectGetPrototypeOf(prototype) + level++ + } +} + +function inspectCapabilityGraphFunction(value, path, graph, budget) { + if (typeof value !== 'function' || reflectApply(isProxy, utilTypesBuiltin, [value])) return + defineCapabilityGraphEntry(graph, path + '[[Function]]', value, budget) + const prototypeDescriptor = ownDataDescriptor(value, 'prototype') + if (prototypeDescriptor && prototypeDescriptor.value !== null && + typeof prototypeDescriptor.value === 'object') { + inspectCapabilityGraphObject( + prototypeDescriptor.value, + path + '.prototype', + graph, + budget + ) + } +} + +function capabilityGraphFor(value, id) { + const graph = objectCreate(null) + const budget = { nodes: 0, properties: 0 } + const descriptors = objectGetOwnPropertyDescriptors(value) + const keys = reflectOwnKeys(value) + for (let index = 0; index < keys.length; index++) { + const key = keys[index] + const descriptor = ownDataValue(descriptors, key) + if (!descriptor || !reflectApply(objectHasOwn, undefined, [descriptor, 'value']) || + descriptor.value === null) continue + const path = id + '.' + capabilityKeyName(key) + if (typeof descriptor.value === 'object') { + inspectCapabilityGraphObject(descriptor.value, path, graph, budget) + } else if (typeof descriptor.value === 'function') { + inspectCapabilityGraphFunction(descriptor.value, path, graph, budget) + } + } + return graph +} + +function applyCapabilityGraphPolicy(target, policy, id) { + const entries = ownDataValue(policy, id) + if (entries === undefined) return + const paths = reflectOwnKeys(entries) + for (let index = 0; index < paths.length; index++) { + const path = paths[index] + const signature = ownDataValue(entries, path) + if (signature === null) { + reflectDeleteProperty(target, path) + } else if (reflectApply(arrayIsArray, undefined, [signature])) { + objectDefineProperty(target, path, { + configurable: true, + enumerable: true, + value: signature, + writable: true + }) + } else { + throw new SafeError('Invalid Node capability graph policy') + } + } +} + +function verifyCapabilityGraph(id, value) { + const expected = objectCreate(null) + applyCapabilityGraphPolicy(expected, preparedNodeCapabilityPolicy.graphBase, id) + if (preparedNodeCapabilityPolicy.use26_8Surface) { + applyCapabilityGraphPolicy(expected, preparedNodeCapabilityPolicy.graphFrom26_8, id) + } + if (preparedNodeCapabilityPolicy.use26_9Surface) { + applyCapabilityGraphPolicy(expected, preparedNodeCapabilityPolicy.graphFrom26_9, id) + } + applyCapabilityGraphPolicy(expected, preparedNodeCapabilityPolicy.graphPlatform, id) + const actual = capabilityGraphFor(value, id) + const optionalPaths = preparedNodeCapabilityPolicy.graphOptionalPaths + for (let index = 0; index < optionalPaths.length; index++) { + const path = optionalPaths[index] + if (ownDataDescriptor(expected, path) && !ownDataDescriptor(actual, path)) { + reflectDeleteProperty(expected, path) + } + } + const expectedPaths = reflectOwnKeys(expected) + const actualPaths = reflectOwnKeys(actual) + reflectApply(arraySort, expectedPaths, []) + reflectApply(arraySort, actualPaths, []) + if (expectedPaths.length !== actualPaths.length) { + const missing = [] + const unexpected = [] + let expectedIndex = 0 + let actualIndex = 0 + while (expectedIndex < expectedPaths.length || actualIndex < actualPaths.length) { + const expectedPath = expectedPaths[expectedIndex] + const actualPath = actualPaths[actualIndex] + if (expectedPath === actualPath) { + expectedIndex++ + actualIndex++ + } else if (actualPath === undefined || + (expectedPath !== undefined && expectedPath < actualPath)) { + if (missing.length < 20) reflectApply(arrayPush, missing, [expectedPath]) + expectedIndex++ + } else { + if (unexpected.length < 20) reflectApply(arrayPush, unexpected, [actualPath]) + actualIndex++ + } + } + throw new SafeError( + 'Unreviewed nested Node capability surface: ' + id + + ' (missing [' + reflectApply(arrayJoin, missing, [',']) + + '], unexpected [' + reflectApply(arrayJoin, unexpected, [',']) + '])' + ) + } + for (let index = 0; index < actualPaths.length; index++) { + if (actualPaths[index] !== expectedPaths[index]) { + throw new SafeError('Unreviewed nested Node capability surface: ' + id) + } + const expectedSignature = ownDataValue(expected, expectedPaths[index]) + const actualSignature = ownDataValue(actual, actualPaths[index]) + if (expectedSignature.length !== actualSignature.length) { + throw new SafeError( + 'Unreviewed nested Node capability surface: ' + id + + ' at ' + actualPaths[index] + ' (expected ' + expectedSignature.length + + ' properties, observed ' + actualSignature.length + ')' + ) + } + for (let entry = 0; entry < actualSignature.length; entry++) { + if (!capabilitySignatureMatches(expectedSignature[entry], actualSignature[entry])) { + throw new SafeError( + 'Unreviewed nested Node capability surface: ' + id + + ' at ' + actualPaths[index] + ' (expected ' + expectedSignature[entry] + + ', observed ' + actualSignature[entry] + ')' + ) + } + } + } +} + +function verifyNodeCapabilityGraphs() { + const ids = preparedNodeCapabilityPolicy.surfacedIds + for (let index = 0; index < ids.length; index++) { + const id = ids[index] + const specifier = reflectApply(stringIndexOf, id, ['node:']) === 0 + ? id + : 'node:' + id + verifyCapabilityGraph(id, reflectApply(moduleLoad, moduleBuiltin, [specifier])) + } +} + +function installNodeCapabilityHook() { + nodeCapabilityHook = reflectApply(moduleRegisterHooks, moduleBuiltin, [objectFreeze({ + resolve(specifier, context, nextResolve) { + enforceBuiltinPolicy(specifier) + return reflectApply(nextResolve, undefined, [specifier, context]) + } + })]) + if (nodeCapabilityHook === null || typeof nodeCapabilityHook !== 'object') { + throw new SafeError('Failed to install Node capability policy') + } +} + function hardenDangerousBuiltins() { // Existing numeric file descriptors bypass Node's Permission Model and are // shared by every thread. Source-string workers disable the complete fs @@ -963,7 +1508,10 @@ function hardenDangerousBuiltins() { } denyFunctions(ttyBuiltin, 'node:tty') denyFunctions(netBuiltin, 'node:net') - denyFunctions(tlsBuiltin, 'node:tls') + // rootCertificates is a non-configurable data accessor on supported Node + // releases. It exposes public certificate data rather than a callable + // capability, so retain it while denying every callable TLS export. + denyFunctions(tlsBuiltin, 'node:tls', new Set(['rootCertificates'])) denyFunctions(dgramBuiltin, 'node:dgram') denyFunctions(dnsBuiltin, 'node:dns') denyFunctions(dnsPromisesBuiltin, 'node:dns/promises') @@ -977,6 +1525,20 @@ function hardenDangerousBuiltins() { replaceProperty(cryptoBuiltin, 'setEngine', () => sandboxDenied('node:crypto.setEngine')) replaceProperty(cryptoBuiltin, 'setFips', () => sandboxDenied('node:crypto.setFips')) replaceProperty(cryptoBuiltin, 'secureHeapUsed', () => sandboxDenied('node:crypto.secureHeapUsed')) + for (const name of [ + 'ZipBuffer', + 'ZipEntry', + 'ZipFile', + 'createZipArchive', + 'createZipArchiveSync', + 'getMaxZipContentSize', + 'setMaxZipContentSize', + 'zipFiles' + ]) { + if (ownPropertyDescriptor(zlibBuiltin, name)) { + replaceProperty(zlibBuiltin, name, () => sandboxDenied('node:zlib.' + name)) + } + } for (const builtin of networkAliasBuiltins) { denyFunctions(builtin, 'internal network builtin') } @@ -1016,17 +1578,11 @@ function hardenDangerousBuiltins() { ) }) replaceProperty(moduleBuiltin, '_load', function restrictedModuleLoad(request, parent, isMain) { - if (request === 'trace_events' || request === 'node:trace_events' || - request === 'quic' || request === 'node:quic') { - return sandboxDenied(request) - } + enforceBuiltinPolicy(request) return reflectApply(moduleLoad, moduleBuiltin, [request, parent, isMain]) }) replaceProperty(processBuiltin, 'getBuiltinModule', function restrictedGetBuiltinModule(request) { - if (request === 'trace_events' || request === 'node:trace_events' || - request === 'quic' || request === 'node:quic') { - return sandboxDenied(request) - } + enforceBuiltinPolicy(request) return reflectApply(processGetBuiltinModule, processBuiltin, [request]) }) for (const name of [ @@ -1064,6 +1620,7 @@ function hardenDangerousBuiltins() { 'availableMemory', 'constrainedMemory', 'cpuUsage', + 'getActiveResourcesInfo', 'getegid', 'geteuid', 'getgid', @@ -1076,6 +1633,9 @@ function hardenDangerousBuiltins() { ]) { replaceProperty(processBuiltin, name, () => sandboxDenied('process.' + name)) } + const noActiveResources = () => objectFreeze([]) + replaceProperty(processBuiltin, '_getActiveHandles', noActiveResources) + replaceProperty(processBuiltin, '_getActiveRequests', noActiveResources) // Undocumented native bindings bypass public-module taming and can operate // directly on the process-wide descriptor table. for (const name of ['binding', '_linkedBinding', 'dlopen']) { @@ -2061,6 +2621,7 @@ async function initialize() { } process.permission.drop('worker') if (process.permission.has('worker')) throw new Error('Failed to drop the worker permission') + await verifyNodeCapabilityPolicy() const channel = new MessageChannel() port = channel.port1 @@ -2097,6 +2658,9 @@ async function initialize() { parentPort.postMessage(handshake, transferList) parentPort.close() hardenDangerousBuiltins() + await verifyNodeCapabilityNamespaces() + verifyNodeCapabilityGraphs() + installNodeCapabilityHook() port.on('messageerror', () => { reportFatal(new Error('The protocol message could not be deserialized')) @@ -2209,4 +2773,4 @@ thenPromise(initialize(), undefined, (error) => { parentPort.close() } }) -})() +})(__NODE_CAPABILITY_BOOTSTRAP_SOURCE__) \ No newline at end of file diff --git a/src/session.js b/src/session.js index 6a329fd..fd6fcec 100644 --- a/src/session.js +++ b/src/session.js @@ -41,6 +41,21 @@ import { isPublicHostFunctionError, validateHostFunctions } from './host-functions.js' +import { + NODE_BUILTIN_POLICY, + NODE_BUILTIN_PROFILES +} from './node-capability-policy.js' +import { + NODE_BUILTIN_GRAPH_BASE, + NODE_BUILTIN_GRAPH_FROM_26_8, + NODE_BUILTIN_GRAPH_FROM_26_9, + NODE_BUILTIN_GRAPH_OPTIONAL_PATHS, + NODE_BUILTIN_GRAPH_PLATFORM, + NODE_BUILTIN_SURFACE_BASE, + NODE_BUILTIN_SURFACE_FROM_26_8, + NODE_BUILTIN_SURFACE_FROM_26_9, + NODE_BUILTIN_SURFACE_PLATFORM +} from './node-capability-surfaces.js' // Snapshot builtin ESM bindings before caller-controlled option processing can // synchronize poisoned CommonJS builtin exports. @@ -78,6 +93,7 @@ const SafePromise = Promise const safeArrayBufferIsView = ArrayBuffer.isView const hostArrayIsArray = Array.isArray const hostArrayPrototype = Array.prototype +const hostArrayJoin = Array.prototype.join const hostArrayPush = Array.prototype.push const hostArrayShift = Array.prototype.shift const hostArraySplice = Array.prototype.splice @@ -93,6 +109,7 @@ const hostObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor const hostObjectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors const hostObjectGetPrototypeOf = Object.getPrototypeOf const hostObjectHasOwn = Object.hasOwn +const hostJSONStringify = JSON.stringify const hostPromiseReject = Promise.reject const hostPromiseResolve = Promise.resolve const hostPromiseThen = Promise.prototype.then @@ -141,6 +158,7 @@ const hostAsyncLocalStorageRun = AsyncLocalStorage.prototype.run const hostBufferFrom = Buffer.from const hostNumberIsSafeInteger = Number.isSafeInteger const hostProcessNextTick = process.nextTick +const hostStringIndexOf = String.prototype.indexOf const hostStringSlice = String.prototype.slice function hostOwnDataDescriptor (value, key) { @@ -155,6 +173,41 @@ function hostOwnDataDescriptor (value, key) { return descriptor } +function serializeTrustedBootstrapValue (value) { + if (value === null || typeof value === 'string' || typeof value === 'boolean' || + typeof value === 'number') { + return hostReflectApply(hostJSONStringify, undefined, [value]) + } + if (value === null || typeof value !== 'object' || safeHostIsProxy(value)) { + throw new TypeError('Invalid trusted bootstrap value') + } + if (hostReflectApply(hostArrayIsArray, undefined, [value])) { + const lengthDescriptor = hostOwnDataDescriptor(value, 'length') + if (!lengthDescriptor || !hostNumberIsSafeInteger(lengthDescriptor.value) || + lengthDescriptor.value < 0) { + throw new TypeError('Invalid trusted bootstrap array') + } + const entries = [] + for (let index = 0; index < lengthDescriptor.value; index++) { + const descriptor = hostOwnDataDescriptor(value, index) + if (!descriptor) throw new TypeError('Sparse trusted bootstrap array') + entries[index] = serializeTrustedBootstrapValue(descriptor.value) + } + return `[${hostReflectApply(hostArrayJoin, entries, [','])}]` + } + + const entries = [] + const keys = hostReflectApply(hostReflectOwnKeys, undefined, [value]) + for (let index = 0; index < keys.length; index++) { + const key = keys[index] + if (typeof key !== 'string') throw new TypeError('Invalid trusted bootstrap object key') + const descriptor = hostOwnDataDescriptor(value, key) + if (!descriptor) throw new TypeError('Invalid trusted bootstrap object property') + entries[index] = `${hostReflectApply(hostJSONStringify, undefined, [key])}:${serializeTrustedBootstrapValue(descriptor.value)}` + } + return `{${hostReflectApply(hostArrayJoin, entries, [','])}}` +} + function hostOwnDataValue (value, key) { const descriptor = hostOwnDataDescriptor(value, key) return descriptor?.value @@ -445,10 +498,44 @@ const DIAGNOSTIC_LEVELS = new Set([ ]) let trustedSessionMethods -const SESSION_BOOTSTRAP = readFileSync( +const NODE_CAPABILITY_BOOTSTRAP_SOURCE = serializeTrustedBootstrapValue({ + graphBase: NODE_BUILTIN_GRAPH_BASE, + graphFrom26_8: NODE_BUILTIN_GRAPH_FROM_26_8, + graphFrom26_9: NODE_BUILTIN_GRAPH_FROM_26_9, + graphOptionalPaths: NODE_BUILTIN_GRAPH_OPTIONAL_PATHS, + graphPlatform: NODE_BUILTIN_GRAPH_PLATFORM, + policy: NODE_BUILTIN_POLICY, + profiles: NODE_BUILTIN_PROFILES, + surfaceBase: NODE_BUILTIN_SURFACE_BASE, + surfaceFrom26_8: NODE_BUILTIN_SURFACE_FROM_26_8, + surfaceFrom26_9: NODE_BUILTIN_SURFACE_FROM_26_9, + surfacePlatform: NODE_BUILTIN_SURFACE_PLATFORM +}) + +const NODE_CAPABILITY_BOOTSTRAP_MARKER = '__NODE_CAPABILITY_BOOTSTRAP_SOURCE__' +const SESSION_BOOTSTRAP_TEMPLATE = readFileSync( `${import.meta.dirname}/session-bootstrap.js`, 'utf8' ) +const nodeCapabilityBootstrapOffset = hostReflectApply( + hostStringIndexOf, + SESSION_BOOTSTRAP_TEMPLATE, + [NODE_CAPABILITY_BOOTSTRAP_MARKER] +) +if (nodeCapabilityBootstrapOffset < 0 || hostReflectApply( + hostStringIndexOf, + SESSION_BOOTSTRAP_TEMPLATE, + [NODE_CAPABILITY_BOOTSTRAP_MARKER, nodeCapabilityBootstrapOffset + 1] +) >= 0) { + throw new Error('Invalid session bootstrap capability marker') +} +const SESSION_BOOTSTRAP = + hostReflectApply(hostStringSlice, SESSION_BOOTSTRAP_TEMPLATE, [0, nodeCapabilityBootstrapOffset]) + + NODE_CAPABILITY_BOOTSTRAP_SOURCE + + hostReflectApply(hostStringSlice, SESSION_BOOTSTRAP_TEMPLATE, [ + nodeCapabilityBootstrapOffset + NODE_CAPABILITY_BOOTSTRAP_MARKER.length + ]) + function createInternalSessionOptions (releaseWorkerSlot) { const key = hostObjectFreeze({}) diff --git a/test/index.test.js b/test/index.test.js index aa57fd8..e861975 100644 --- a/test/index.test.js +++ b/test/index.test.js @@ -1258,8 +1258,8 @@ throw new Error('located')`, { timeoutMs: 5_000 }), (error) => { assert.match(error.remoteStack, /^Error: located\n/) assert.match(error.remoteStack, /at eval \(secure-eval-worker-one-shot\.js:3:7\)/) - assert.match(error.remoteStack, /at trustedBootstrap \(\[worker eval\]:\d+:\d+\)/) - assert.match(error.remoteStack, /node:internal\/process\/execution/) + assert.match(error.remoteStack, /at (?:trustedBootstrap|initialize) \(\[worker eval\]:\d+:\d+\)/) + assert.match(error.remoteStack, /node:internal\/process\//) assert.doesNotMatch(error.remoteStack, /hostile\.js/) return true } diff --git a/test/local-files.test.js b/test/local-files.test.js index 5eccd82..c224ba8 100644 --- a/test/local-files.test.js +++ b/test/local-files.test.js @@ -644,34 +644,35 @@ test('bounds guest-opened descriptors across every filesystem alias', async (t) }), 'ERR_UNTRUSTED_FILE_DESCRIPTOR_LIMIT') }) -test('descriptor accounting uses the captured typed-array length getter', async (t) => { +test('module hooks lock the inherited typed-array length getter', async (t) => { const files = await fixture({ 'entry.mjs': ` import fs from 'node:fs' export default () => { - let reads = 0 const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype) const descriptor = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'length') - Object.defineProperty(typedArrayPrototype, 'length', { - ...descriptor, - get () { - reads++ - throw new Error('poisoned typed-array length') - } - }) + let mutationError + try { + Object.defineProperty(typedArrayPrototype, 'length', { + ...descriptor, + get () { throw new Error('poisoned typed-array length') } + }) + } catch (error) { + mutationError = error.name + } const descriptorNumber = fs.openSync(new URL('./value.txt', import.meta.url), 'r') fs.closeSync(descriptorNumber) - return reads + return { configurable: descriptor.configurable, mutationError } } `, 'value.txt': 'captured length' }) t.after(() => files.cleanup()) - assert.equal(await runUntrustedFile(files.path('entry.mjs'), { + assert.deepEqual(await runUntrustedFile(files.path('entry.mjs'), { rootDirectory: files.directory, timeoutMs: 5_000 - }), 0) + }), { configurable: false, mutationError: 'TypeError' }) }) test('physical package copies share the descriptor quota and release it on exit', async (t) => { diff --git a/test/node-capabilities.test.js b/test/node-capabilities.test.js new file mode 100644 index 0000000..5430bdf --- /dev/null +++ b/test/node-capabilities.test.js @@ -0,0 +1,87 @@ +import assert from 'node:assert/strict' +import { test } from 'node:test' + +import { + descriptorSignature, + diffExactLists, + diffSurfaceSignatures +} from '../scripts/node-capability-signatures.js' + +test('capability signatures reject synthetic API drift without invoking accessors', () => { + let getterCalls = 0 + const baseline = Object.create(null) + Object.defineProperty(baseline, 'stable', { + enumerable: true, + value: 1 + }) + Object.defineProperty(baseline, 'lazy', { + enumerable: true, + get () { + getterCalls++ + throw new Error('accessor must not run') + } + }) + const expected = descriptorSignature(baseline) + assert.equal(getterCalls, 0) + + const addedSymbol = Symbol('new-capability') + const changed = Object.create(null) + Object.defineProperty(changed, 'stable', { + enumerable: true, + value: () => 'new callable' + }) + Object.defineProperty(changed, 'lazy', { + enumerable: true, + get () { + getterCalls++ + throw new Error('accessor must not run') + } + }) + Object.defineProperty(changed, 'addedAccessor', { + get () { + getterCalls++ + throw new Error('accessor must not run') + } + }) + Object.defineProperty(changed, addedSymbol, { + value: () => 'new symbolic callable' + }) + + const actual = descriptorSignature(changed) + const diff = diffSurfaceSignatures(expected, actual) + assert.equal(getterCalls, 0) + assert.deepEqual(diff.added, [ + '@@new-capability:f', + 'addedAccessor:a', + 'stable:f' + ]) + assert.deepEqual(diff.removed, ['stable:n']) +}) + +test('capability comparisons distinguish module and namespace additions from removals', () => { + assert.deepEqual( + diffExactLists(['node:approved', 'node:removed'], ['node:approved', 'node:new']), + { added: ['node:new'], removed: ['node:removed'] } + ) + assert.deepEqual( + diffSurfaceSignatures(['default:o', 'stable:n'], ['default:o', 'future:f'], { + namesOnly: true + }), + { added: ['future:f'], removed: ['stable:n'] } + ) +}) + +test('constructor prototype additions are visible to the graph signature', () => { + class Reviewed {} + const expected = descriptorSignature(Reviewed.prototype) + Object.defineProperty(Reviewed.prototype, 'futureAuthority', { + value () {} + }) + assert.deepEqual(diffSurfaceSignatures( + expected, + descriptorSignature(Reviewed.prototype) + ), { + added: ['futureAuthority:f'], + removed: [] + }) +}) diff --git a/test/security.test.js b/test/security.test.js index 94fe287..52d5f54 100644 --- a/test/security.test.js +++ b/test/security.test.js @@ -2,7 +2,6 @@ import assert from 'node:assert/strict' import { spawnSync } from 'node:child_process' import { randomUUID, webcrypto } from 'node:crypto' import fs from 'node:fs' -import { builtinModules } from 'node:module' import { tmpdir } from 'node:os' import { connect, createServer } from 'node:net' import { join } from 'node:path' @@ -11,6 +10,7 @@ import { test } from 'node:test' import { getEnvironmentData, setEnvironmentData } from 'node:worker_threads' import { + configureWorkerAdmission, createUntrustedWorker, createUntrustedWorkerFromFile, runUntrustedCode, @@ -107,6 +107,98 @@ for (const type of EXECUTION_TYPES) { assert.equal(code, 'ERR_ACCESS_DENIED') }) + test(`${type} denies unapproved builtins through every loading path`, async () => { + const result = await evaluateInGuest(type, ` + const Module = await import('node:module') + const processModule = await import('node:process') + const vm = await import('node:vm') + const require = Module.createRequire(process.execPath) + const commonNodeModule = require('node:module') + const commonBareModule = require('module') + const loadedModule = Module.Module._load('node:module') + const builtinModule = process.getBuiltinModule('node:module') + const mutationResults = [] + for (const [target, name] of [ + [Module, '_load'], + [Module.default, '_load'], + [Module, 'registerHooks'], + [Module.default, 'registerHooks'], + [process, 'getBuiltinModule'], + [processModule.default, 'getBuiltinModule'] + ]) { + mutationResults.push([ + Reflect.set(target, name, () => 'ALLOWED'), + Reflect.deleteProperty(target, name), + Reflect.defineProperty(target, name, { + configurable: true, + value: () => 'ALLOWED' + }) + ]) + } + Module.syncBuiltinESMExports() + Module.default.syncBuiltinESMExports() + Module.syncBuiltinESMExports() + + const loaderCodes = [ + Module.registerHooks, + Module.default.registerHooks, + Module.Module.registerHooks, + commonNodeModule.registerHooks, + commonBareModule.registerHooks, + loadedModule.registerHooks, + builtinModule.registerHooks + ].map(registerHooks => { + try { + Reflect.apply(registerHooks, undefined, [{ resolve () { return 'ALLOWED' } }]) + return 'ALLOWED' + } catch (error) { + return error.code + } + }) + + const attempts = [ + () => import('node:diagnostics_channel'), + () => import('diagnostics_channel'), + () => require('node:diagnostics_channel'), + () => require('diagnostics_channel'), + () => Module._load('node:diagnostics_channel'), + () => Module.Module._load('diagnostics_channel'), + () => Module.default._load('node:diagnostics_channel'), + () => process.getBuiltinModule('node:diagnostics_channel'), + () => processModule.getBuiltinModule('node:diagnostics_channel'), + () => processModule.default.getBuiltinModule('diagnostics_channel'), + () => process.getBuiltinModule('node:module')._load('node:diagnostics_channel'), + () => process.getBuiltinModule('module')._load('diagnostics_channel'), + () => new vm.Script("import('node:diagnostics_channel')", { + importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER + }).runInThisContext(), + () => vm.compileFunction("return import('diagnostics_channel')", [], { + importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER + })() + ] + const codes = [] + for (const attempt of attempts) { + try { + await attempt() + codes.push('ALLOWED') + } catch (error) { + codes.push(error.code) + } + } + return { + codes, + loaderCodes, + mutationResults, + approved: (await import('node:path')).join('a', 'b') + } + `) + assert.deepEqual(result.codes, Array(14).fill('ERR_ACCESS_DENIED')) + assert.deepEqual(result.loaderCodes, Array(7).fill('ERR_ACCESS_DENIED')) + assert.deepEqual(result.mutationResults, Array.from({ length: 6 }, () => + [false, false, false])) + assert.equal(result.approved, join('a', 'b')) + }) + test(`${type} denies WASI, FFI, and unavailable native capability modules`, async () => { const result = await evaluateInGuest(type, ` const Module = await import('node:module') @@ -151,28 +243,22 @@ for (const type of EXECUTION_TYPES) { Module.syncBuiltinESMExports() const wasi = wasiModules.map(module => invoke(module, 'WASI', true)) - let ffiNames = [] - let ffiModules = [] - try { - const nodeFfi = await import('node:ffi') - ffiNames = Reflect.ownKeys(nodeFfi.default).filter(name => - typeof name === 'string' && typeof nodeFfi.default[name] === 'function') - ffiModules = [ - nodeFfi, - nodeFfi.default, - process.getBuiltinModule('node:ffi'), - require('node:ffi'), - Module._load('node:ffi'), - Module.default._load('node:ffi') - ] - } catch {} - const ffiMutations = ffiModules.map(module => - ffiNames.map(name => mutationResult(module, name))) - Module.syncBuiltinESMExports() - Module.default.syncBuiltinESMExports() - Module.syncBuiltinESMExports() - const ffi = ffiModules.map(module => - ffiNames.map(name => invoke(module, name))) + const ffi = [] + for (const load of [ + () => import('node:ffi'), + () => process.getBuiltinModule('node:ffi'), + () => require('node:ffi'), + () => Module._load('node:ffi'), + () => Module.Module._load('node:ffi'), + () => Module.default._load('node:ffi') + ]) { + try { + await load() + ffi.push('ALLOWED') + } catch (error) { + ffi.push(error.code) + } + } let bareFfiImported = false let bareFfiRequired = false @@ -209,8 +295,6 @@ for (const type of EXECUTION_TYPES) { wasi, wasiMutations, ffi, - ffiNames, - ffiMutations, ffiBare, unavailable } @@ -221,16 +305,7 @@ for (const type of EXECUTION_TYPES) { delete: false, define: false }))) - const ffiAvailable = builtinModules.some(id => id === 'ffi' || id === 'node:ffi') - assert.equal(result.ffiNames.length > 20, ffiAvailable) - assert.deepEqual(result.ffi, Array.from({ length: ffiAvailable ? 6 : 0 }, () => - Array(result.ffiNames.length).fill('ERR_ACCESS_DENIED'))) - assert.deepEqual(result.ffiMutations, Array.from({ length: ffiAvailable ? 6 : 0 }, () => - Array.from({ length: result.ffiNames.length }, () => ({ - set: false, - delete: false, - define: false - })))) + assert.deepEqual(result.ffi, Array(6).fill('ERR_ACCESS_DENIED')) assert.deepEqual(result.ffiBare, { imported: false, required: false, @@ -247,6 +322,63 @@ for (const type of EXECUTION_TYPES) { }) }) + test(`${type} denies Node 26.8 ZIP filesystem APIs through every alias`, async () => { + const result = await evaluateInGuest(type, ` + const Module = await import('node:module') + const require = Module.createRequire(process.execPath) + const nodeNamespace = await import('node:zlib') + const bareNamespace = await import('zlib') + const aliases = [ + nodeNamespace, + nodeNamespace.default, + bareNamespace, + bareNamespace.default, + require('node:zlib'), + require('zlib'), + Module._load('node:zlib'), + Module.default._load('zlib'), + process.getBuiltinModule('node:zlib'), + process.getBuiltinModule('zlib') + ] + const names = [ + 'ZipBuffer', + 'ZipEntry', + 'ZipFile', + 'createZipArchive', + 'createZipArchiveSync', + 'getMaxZipContentSize', + 'setMaxZipContentSize', + 'zipFiles' + ].filter(name => typeof aliases[0][name] === 'function') + const mutations = aliases.map(alias => names.map(name => [ + Reflect.set(alias, name, () => 'ALLOWED'), + Reflect.deleteProperty(alias, name), + Reflect.defineProperty(alias, name, { + configurable: true, + value: () => 'ALLOWED' + }) + ])) + Module.syncBuiltinESMExports() + Module.default.syncBuiltinESMExports() + Module.syncBuiltinESMExports() + const codes = aliases.map(alias => names.map(name => { + try { + Reflect.apply(alias[name], undefined, []) + return 'ALLOWED' + } catch (error) { + return error.code + } + })) + return { names, mutations, codes } + `) + const expectedNames = Number(process.versions.node.split('.')[1]) >= 8 ? 8 : 0 + assert.equal(result.names.length, expectedNames) + assert.deepEqual(result.codes, Array.from({ length: 10 }, () => + Array(expectedNames).fill('ERR_ACCESS_DENIED'))) + assert.deepEqual(result.mutations, Array.from({ length: 10 }, () => + Array.from({ length: expectedNames }, () => [false, false, false]))) + }) + test(`${type} cannot use host file descriptors`, async (t) => { const path = join(tmpdir(), `secure-eval-worker-${randomUUID()}.txt`) fs.writeFileSync(path, 'file-descriptor-secret') @@ -1216,6 +1348,43 @@ test('sanitizes host process metadata in every execution mode', async () => { } }) +test('static ESM policy failures are bounded and release admission', async (t) => { + configureWorkerAdmission({ maxConcurrentWorkers: 1 }) + t.after(() => configureWorkerAdmission({ maxConcurrentWorkers: 8 })) + const startedAt = Date.now() + const sourceSession = createUntrustedWorker(` + import 'node:diagnostics_channel' + export default () => {} + `, { + type: 'module', + startupTimeoutMs: 5_000, + lifetimeTimeoutMs: 5_000 + }) + await assert.rejects(sourceSession.ready, (error) => { + assert.equal(error.remoteCode, 'ERR_ACCESS_DENIED') + return true + }) + await sourceSession.closed + assert.equal(await runUntrustedCode('return 41', { timeoutMs: 5_000 }), 41) + + const root = fs.mkdtempSync(join(tmpdir(), 'secure-eval-static-policy-')) + t.after(() => fs.rmSync(root, { force: true, recursive: true })) + const entry = join(root, 'entry.mjs') + fs.writeFileSync(entry, ` + import 'node:diagnostics_channel' + export default () => 'ALLOWED' + `) + await assert.rejects(runUntrustedFile(entry, { + rootDirectory: root, + timeoutMs: 5_000 + }), (error) => { + assert.equal(error.remoteCode, 'ERR_ACCESS_DENIED') + return true + }) + assert.equal(await runUntrustedCode('return 42', { timeoutMs: 5_000 }), 42) + assert.equal(Date.now() - startedAt < 5_000, true) +}) + test('does not inherit host command-line arguments', () => { const moduleUrl = new URL('../src/index.js', import.meta.url).href const marker = `CLI_SECRET_${randomUUID()}` @@ -1282,7 +1451,7 @@ test('cannot wrap an existing host socket descriptor', async (t) => { } })) `, { timeoutMs: 5_000 }) - assert.deepEqual(results, ['ERR_ACCESS_DENIED', 'BLOCKED', 'BLOCKED']) + assert.deepEqual(results, ['ERR_ACCESS_DENIED', 'ERR_ACCESS_DENIED', 'BLOCKED']) assert.equal(socket.destroyed, false) }) diff --git a/test/session.test.js b/test/session.test.js index 40b95f4..6e7220e 100644 --- a/test/session.test.js +++ b/test/session.test.js @@ -1167,7 +1167,7 @@ test('persistent runtime errors preserve complete stacks with stable guest filen `const value = 1 throw new Error('script location')`, /secure-eval-worker-component\.js:2:7/, - /at trustedBootstrap \(\[worker eval\]:\d+:\d+\)/ + /at (?:trustedBootstrap|initialize) \(\[worker eval\]:\d+:\d+\)/ ], [ 'module',