From 38df94da970373aba9c839d004520dfd8e28cd58 Mon Sep 17 00:00:00 2001 From: rdlabo Date: Fri, 23 Oct 2026 07:55:20 +0900 Subject: [PATCH 1/8] feat: checkpoint Node compatibility expansion and review fixes --- .github/workflows/ci.yml | 2 + .prettierignore | 3 + CONTRIBUTING.md | 14 + demo/package.json | 8 +- .../node-compat/completion-report.mjs | 270 +++ .../node-compat/completion-report.test.mjs | 78 + .../node-compat/events-baseline.probe.mjs | 56 + .../node-compat/events-contracts.probe.mjs | 218 ++ .../experiments/node-compat/events-native.mjs | 254 +++ .../node-compat/events-surface.probe.mjs | 115 ++ .../node-compat/expansion-contracts.probe.mjs | 223 +++ .../node-compat/expansion-native.mjs | 294 +++ .../experiments/node-compat/export-types.json | 1746 +++++++++++++++++ .../node-compat/inventory.test.mjs | 19 + .../node-compat/local-surface.test.mjs | 38 +- .../node-compat/prepare-events-consumer.mjs | 68 + .../experiments/node-compat/surface-gaps.json | 485 +---- .../node-compat/surface-regressions.mjs | 5 + .../node-compat/surface-regressions.test.mjs | 14 + docs/compatibility.md | 82 +- .../workerscapacitor/WorkerSockets.java | 5 +- .../WorkersCapacitorPlugin.java | 4 +- native/ios/NetworkBridge.swift | 2 +- native/ios/SocketBridge.swift | 11 +- package.json | 6 +- scripts/build-codecs.mjs | 53 + scripts/build-native-codecs.mjs | 76 + scripts/build-native-crypto.mjs | 95 + scripts/build-workers-streams.mjs | 107 + scripts/test-package.mjs | 16 + src/browser/fetch/host-call.ts | 4 + src/browser/isolated/transport.ts | 33 +- src/browser/request/index.ts | 10 +- src/cloudflare/workers/worker-runtime.ts | 3 +- src/compat/console/index.ts | 112 ++ src/compat/crypto/LICENSE-3RD-PARTY.md | 15 + src/compat/crypto/LICENSE-APACHE | 177 ++ src/compat/crypto/LICENSE.emscripten | 102 + src/compat/crypto/LICENSE.musl | 193 ++ src/compat/crypto/LICENSE.openssl | 177 ++ src/compat/crypto/asymmetric.ts | 332 ++++ src/compat/crypto/brorand.cjs | 76 + src/compat/crypto/ecdh.ts | 172 ++ src/compat/crypto/hkdf.ts | 85 + src/compat/crypto/index.cjs | 1 + src/compat/crypto/index.ts | 140 ++ src/compat/crypto/key-formats.ts | 143 ++ src/compat/crypto/key-state.ts | 12 + src/compat/crypto/keys.ts | 248 +++ src/compat/crypto/metadata.ts | 22 + src/compat/crypto/native-crypto.build.json | 39 + src/compat/crypto/native-crypto.c | 218 ++ src/compat/crypto/native-crypto.ts | 485 +++++ src/compat/crypto/native-crypto.wasm | Bin 0 -> 1750462 bytes src/compat/crypto/prime.ts | 250 +++ src/compat/crypto/random.ts | 154 ++ src/compat/crypto/rsa.ts | 235 +++ src/compat/crypto/scrypt.ts | 227 +++ src/compat/crypto/sign-errors.ts | 17 + src/compat/crypto/sign-handle.ts | 149 ++ src/compat/crypto/signatures.ts | 436 ++++ src/compat/crypto/symmetric.ts | 131 ++ src/compat/crypto/validation.ts | 26 + src/compat/events/README.md | 57 + src/compat/events/errors.ts | 43 + src/compat/events/index.cjs | 1 + src/compat/events/index.spec.mjs | 426 ++++ src/compat/events/index.ts | 1049 ++++++++++ src/compat/events/intrinsics.ts | 4 + src/compat/events/observations.spec.mjs | 167 ++ src/compat/expansion/README.md | 54 + src/compat/expansion/index.spec.mjs | 1413 +++++++++++++ src/compat/fs/embedded.ts | 298 +++ src/compat/fs/index.ts | 631 +++--- src/compat/fs/mode.ts | 17 + src/compat/fs/promises/index.ts | 36 +- src/compat/fs/writable.spec.ts | 129 ++ src/compat/fs/writable.ts | 153 ++ src/compat/http-common/index.ts | 48 + src/compat/http-outgoing/index.ts | 46 + src/compat/http-server/index.ts | 149 ++ src/compat/http/symbols.ts | 12 + src/compat/module/builtins.ts | 102 + src/compat/module/index.ts | 42 +- src/compat/module/metadata.ts | 154 ++ src/compat/net/internal-net.ts | 4 + src/compat/net/sockets.spec.ts | 21 + src/compat/net/sockets.ts | 4 + src/compat/process/base.d.ts | 38 + src/compat/process/index.cjs | 1 + src/compat/process/index.ts | 203 ++ src/compat/process/metadata.ts | 357 ++++ src/compat/process/state.ts | 4 + src/compat/stream-web/LICENSE | 22 + src/compat/stream-web/README.md | 30 +- src/compat/stream-web/ponyfill.ts | 2 +- src/compat/stream-web/runtime.ts | 6 +- .../stream-web/workers-ponyfill.build.json | 8 + src/compat/stream-web/workers-ponyfill.d.ts | 1 + src/compat/stream-web/workers-ponyfill.js | 3 + src/compat/stream-wrap/LICENSE-3RD-PARTY.md | 11 + src/compat/stream-wrap/LICENSE-APACHE | 177 ++ src/compat/stream-wrap/index.ts | 1 + src/compat/tls-wrap/LICENSE-3RD-PARTY.md | 11 + src/compat/tls-wrap/LICENSE-APACHE | 177 ++ src/compat/tls-wrap/index.ts | 3 + src/compat/tls/LICENSE-3RD-PARTY.md | 11 + src/compat/tls/LICENSE-APACHE | 177 ++ src/compat/tls/README.md | 22 + src/compat/tls/constants.ts | 17 + src/compat/tls/errors.ts | 93 + src/compat/tls/helpers.ts | 277 +++ src/compat/tls/index.ts | 73 + src/compat/tls/jsstream.ts | 221 +++ src/compat/tls/upgrade.spec.ts | 55 + src/compat/tls/wrap.ts | 793 ++++++++ src/compat/util/index.ts | 45 +- src/compat/util/types/index.ts | 49 + src/compat/zlib/LICENSE.brotli | 19 + src/compat/zlib/LICENSE.emscripten | 102 + src/compat/zlib/LICENSE.musl | 193 ++ src/compat/zlib/LICENSE.zstd | 30 + src/compat/zlib/compression.ts | 334 ++++ src/compat/zlib/constants.ts | 173 ++ src/compat/zlib/index.ts | 398 ++++ src/compat/zlib/native-codecs.build.json | 8 + src/compat/zlib/native-codecs.c | 45 + src/compat/zlib/native-codecs.ts | 163 ++ src/compat/zlib/native-codecs.wasm | Bin 0 -> 1181723 bytes src/compat/zlib/wasm.d.ts | 4 + src/shared/globals/inject.ts | 3 +- src/shared/globals/runtime.ts | 3 +- src/shared/request-scope.ts | 15 + src/tooling/async.ts | 51 +- src/tooling/shared.ts | 27 +- src/tooling/vite.ts | 6 +- tests/unit/async-build.test.ts | 46 + tests/unit/opennext-compat.test.ts | 7 - vitest.config.ts | 2 + 139 files changed, 17495 insertions(+), 873 deletions(-) create mode 100644 demo/tests/experiments/node-compat/completion-report.mjs create mode 100644 demo/tests/experiments/node-compat/completion-report.test.mjs create mode 100644 demo/tests/experiments/node-compat/events-baseline.probe.mjs create mode 100644 demo/tests/experiments/node-compat/events-contracts.probe.mjs create mode 100644 demo/tests/experiments/node-compat/events-native.mjs create mode 100644 demo/tests/experiments/node-compat/events-surface.probe.mjs create mode 100644 demo/tests/experiments/node-compat/expansion-contracts.probe.mjs create mode 100644 demo/tests/experiments/node-compat/expansion-native.mjs create mode 100644 demo/tests/experiments/node-compat/export-types.json create mode 100644 demo/tests/experiments/node-compat/prepare-events-consumer.mjs create mode 100644 scripts/build-native-codecs.mjs create mode 100644 scripts/build-native-crypto.mjs create mode 100644 scripts/build-workers-streams.mjs create mode 100644 src/compat/console/index.ts create mode 100644 src/compat/crypto/LICENSE-3RD-PARTY.md create mode 100644 src/compat/crypto/LICENSE-APACHE create mode 100644 src/compat/crypto/LICENSE.emscripten create mode 100644 src/compat/crypto/LICENSE.musl create mode 100644 src/compat/crypto/LICENSE.openssl create mode 100644 src/compat/crypto/asymmetric.ts create mode 100644 src/compat/crypto/brorand.cjs create mode 100644 src/compat/crypto/ecdh.ts create mode 100644 src/compat/crypto/hkdf.ts create mode 100644 src/compat/crypto/index.cjs create mode 100644 src/compat/crypto/index.ts create mode 100644 src/compat/crypto/key-formats.ts create mode 100644 src/compat/crypto/key-state.ts create mode 100644 src/compat/crypto/keys.ts create mode 100644 src/compat/crypto/metadata.ts create mode 100644 src/compat/crypto/native-crypto.build.json create mode 100644 src/compat/crypto/native-crypto.c create mode 100644 src/compat/crypto/native-crypto.ts create mode 100755 src/compat/crypto/native-crypto.wasm create mode 100644 src/compat/crypto/prime.ts create mode 100644 src/compat/crypto/random.ts create mode 100644 src/compat/crypto/rsa.ts create mode 100644 src/compat/crypto/scrypt.ts create mode 100644 src/compat/crypto/sign-errors.ts create mode 100644 src/compat/crypto/sign-handle.ts create mode 100644 src/compat/crypto/signatures.ts create mode 100644 src/compat/crypto/symmetric.ts create mode 100644 src/compat/crypto/validation.ts create mode 100644 src/compat/events/README.md create mode 100644 src/compat/events/errors.ts create mode 100644 src/compat/events/index.cjs create mode 100644 src/compat/events/index.spec.mjs create mode 100644 src/compat/events/index.ts create mode 100644 src/compat/events/intrinsics.ts create mode 100644 src/compat/events/observations.spec.mjs create mode 100644 src/compat/expansion/README.md create mode 100644 src/compat/expansion/index.spec.mjs create mode 100644 src/compat/fs/embedded.ts create mode 100644 src/compat/fs/mode.ts create mode 100644 src/compat/fs/writable.spec.ts create mode 100644 src/compat/fs/writable.ts create mode 100644 src/compat/http-common/index.ts create mode 100644 src/compat/http-outgoing/index.ts create mode 100644 src/compat/http-server/index.ts create mode 100644 src/compat/http/symbols.ts create mode 100644 src/compat/module/builtins.ts create mode 100644 src/compat/module/metadata.ts create mode 100644 src/compat/process/base.d.ts create mode 100644 src/compat/process/index.cjs create mode 100644 src/compat/process/index.ts create mode 100644 src/compat/process/metadata.ts create mode 100644 src/compat/process/state.ts create mode 100644 src/compat/stream-web/LICENSE create mode 100644 src/compat/stream-web/workers-ponyfill.build.json create mode 100644 src/compat/stream-web/workers-ponyfill.d.ts create mode 100644 src/compat/stream-web/workers-ponyfill.js create mode 100644 src/compat/stream-wrap/LICENSE-3RD-PARTY.md create mode 100644 src/compat/stream-wrap/LICENSE-APACHE create mode 100644 src/compat/stream-wrap/index.ts create mode 100644 src/compat/tls-wrap/LICENSE-3RD-PARTY.md create mode 100644 src/compat/tls-wrap/LICENSE-APACHE create mode 100644 src/compat/tls-wrap/index.ts create mode 100644 src/compat/tls/LICENSE-3RD-PARTY.md create mode 100644 src/compat/tls/LICENSE-APACHE create mode 100644 src/compat/tls/README.md create mode 100644 src/compat/tls/constants.ts create mode 100644 src/compat/tls/errors.ts create mode 100644 src/compat/tls/helpers.ts create mode 100644 src/compat/tls/index.ts create mode 100644 src/compat/tls/jsstream.ts create mode 100644 src/compat/tls/upgrade.spec.ts create mode 100644 src/compat/tls/wrap.ts create mode 100644 src/compat/util/types/index.ts create mode 100644 src/compat/zlib/LICENSE.brotli create mode 100644 src/compat/zlib/LICENSE.emscripten create mode 100644 src/compat/zlib/LICENSE.musl create mode 100644 src/compat/zlib/LICENSE.zstd create mode 100644 src/compat/zlib/compression.ts create mode 100644 src/compat/zlib/constants.ts create mode 100644 src/compat/zlib/index.ts create mode 100644 src/compat/zlib/native-codecs.build.json create mode 100644 src/compat/zlib/native-codecs.c create mode 100644 src/compat/zlib/native-codecs.ts create mode 100755 src/compat/zlib/native-codecs.wasm create mode 100644 src/compat/zlib/wasm.d.ts create mode 100644 src/shared/request-scope.ts diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5cd5ee35..ef22d6b0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -102,6 +102,8 @@ jobs: - suite: workers commands: | npm run test:node-inventory + npm run test:events + npm run test:node-expansion npm run test:workers -- --allowOnly=false npm run test:browser - suite: runtime diff --git a/.prettierignore b/.prettierignore index da69bf4a..4422bef0 100644 --- a/.prettierignore +++ b/.prettierignore @@ -28,3 +28,6 @@ demo/tests/native-embedding/android/app/src/main/assets/ demo/tests/native-embedding/android/build/ demo/tests/native-embedding/android/app/build/ demo/tests/native-embedding/android/.gradle/ + +# Generated pinned stream implementation. +src/compat/stream-web/workers-ponyfill.js diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 751d842e..2a48a003 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -69,6 +69,20 @@ not ship it behind an experimental flag as a substitute for finishing it. Design notes and reproducible experiments can be reviewed independently without adding unfinished production behavior. +### Explicit WebView events profile + +The approved events work targets the current WebView architecture with documented +engine boundaries, rather than replacing the engine to seek unrestricted Workers +equivalence. The events adapter and its process event/warning/nextTick integration +may be accepted against the [WebView events profile](src/compat/events/README.md). +This is a scoped exception to unrestricted whole-module equivalence above, not a +blanket exception for new incomplete Node modules. Keep the existing process and +async-hooks limitations visible. Require the shared behavioral contracts, public +Vite/esbuild imports, an independently installed tarball, and iOS/Android page and +Dedicated Worker evidence for this profile. Do not label the complete Node +compatibility inventory or unrestricted Workers behavior **Complete** as a result. +Publishing and release authorization remain separate. + ### 0.1.0 Preview exception 0.1.0 Preview may include existing compatibility implementations with the limitations documented in the [compatibility inventory](docs/compatibility.md). Their inclusion does not establish complete module compatibility or certify untested behavior. Keep missing exports, unsupported operations and verification boundaries visible; a passing application scenario does not make its dependencies complete. diff --git a/demo/package.json b/demo/package.json index 379f3534..1788075a 100644 --- a/demo/package.json +++ b/demo/package.json @@ -40,6 +40,7 @@ "test:runtime:fallback:dev": "playwright test --config tests/playwright.stream-fallback-dev.config.ts", "test:service-bindings": "node --test tests/experiments/services/integration.test.mjs", "test:cloudflare-bindings": "node --test tests/experiments/cloudflare/integration.test.mjs", + "test:node-completion": "npm run test:node-inventory && node tests/experiments/node-compat/completion-report.mjs", "test:node-boundaries": "node --test tests/experiments/node-compat/*.probe.mjs", "test:opennext": "node --test tests/opennext/integration.test.mjs && vite build --config tests/opennext/local/vite.config.ts && node tests/opennext/local/esbuild.mjs && node --test tests/opennext/local.test.mjs", "test:opennext:split": "vite build --config tests/opennext/split/vite.config.ts && node tests/opennext/split/esbuild.mjs && node --test --test-concurrency=1 tests/opennext/split/*.test.mjs", @@ -47,7 +48,12 @@ "test:void:routes": "npm --prefix void run build && node --test tests/void/routes/acceptance.test.mjs", "test:upstream:opennext:prepare": "node tests/upstream/opennext/prepare.mjs", "test:upstream:opennext": "node --test tests/upstream/opennext/acceptance.test.mjs", - "test:upstream:opennext:native": "node --test tests/upstream/opennext/native.test.mjs" + "test:upstream:opennext:native": "node --test tests/upstream/opennext/native.test.mjs", + "test:events": "node --test tests/experiments/node-compat/events-baseline.probe.mjs tests/experiments/node-compat/events-surface.probe.mjs tests/experiments/node-compat/events-contracts.probe.mjs", + "test:events:native:prepare": "node tests/experiments/node-compat/prepare-events-consumer.mjs", + "test:events:native": "node tests/experiments/node-compat/events-native.mjs", + "test:node-expansion": "node --test tests/experiments/node-compat/expansion-contracts.probe.mjs", + "test:node-expansion:native": "node tests/experiments/node-compat/expansion-native.mjs" }, "dependencies": { "@capacitor/core": "^8.5.3", diff --git a/demo/tests/experiments/node-compat/completion-report.mjs b/demo/tests/experiments/node-compat/completion-report.mjs new file mode 100644 index 00000000..44010851 --- /dev/null +++ b/demo/tests/experiments/node-compat/completion-report.mjs @@ -0,0 +1,270 @@ +import assert from "node:assert/strict"; +import { readFile, writeFile } from "node:fs/promises"; +import { fileURLToPath } from "node:url"; +import path from "node:path"; + +const assessments = [ + { + modules: ["events"], + priority: 1, + category: "implementation-and-host-integration", + next: "Public events imports implement the explicitly scoped WebView profile, including process warning delivery and nextTick scheduling. Keep native async and V8 inspection boundaries explicit; this is not unrestricted Workers or process-module certification. See the profile and generated acceptance evidence.", + evidence: [ + "surface-gaps.json", + "events-baseline.probe.mjs", + "events-surface.probe.mjs", + "events-contracts.probe.mjs", + "events-native.mjs", + "../../../../src/compat/events/README.md", + "../../../../src/compat/async-hooks/README.md", + ], + }, + { + modules: ["crypto", "zlib"], + priority: 2, + category: "implementation-gap", + next: "Inventory algorithms, key/codec classes, synchronous and streaming behavior. Evaluate JS/Wasm implementations against all pinned operations; random/hash/HKDF/scrypt, owned secret/asymmetric keys, RSA/EC/Ed25519 signatures, prime generation/checking and Brotli/Zstd profiles now supplement dependency polyfills. X509/Certificate, additional key-generation options, remaining algorithms and complete codec contracts remain open. No technical-impossibility claim has been established.", + evidence: [ + "surface-gaps.json", + "expansion-contracts.probe.mjs", + "expansion-native.mjs", + "../../../../src/compat/expansion/README.md", + ], + }, + { + modules: ["fs", "fs/promises"], + priority: 2, + category: "implementation-gap", + next: "Compare the Workers virtual filesystem, descriptors, FileHandle, writes, permissions and watch behavior. Request-local memory-backed /tmp now supports writes, descriptors and FileHandle; permission no-ops, statfs and embedded-file copying are tested; compare remaining cross-volume operations, descriptors and stream semantics.", + evidence: [ + "../../../../src/compat/fs/index.ts", + "../../../../src/compat/fs/promises/index.ts", + ], + }, + { + modules: ["process", "console"], + priority: 2, + category: "implementation-and-host-integration", + next: "Classify each export as functional or a pinned Workers stub; verify scheduling, streams, events and host-specific introspection independently. Do not substitute standalone Node behavior.", + evidence: ["surface-gaps.json"], + }, + { + modules: ["util", "util/types", "sys", "assert", "assert/strict"], + priority: 3, + category: "engine-boundary", + next: "Separate ordinary JS algorithms and sys alias routing from unobservable proxy/promise state, call sites and host brands. Closing the export list will not complete these modules or assertion diagnostics.", + evidence: [ + "engine-boundaries.probe.mjs", + "../../../../src/compat/util/README.md", + ], + }, + { + modules: ["async_hooks", "diagnostics_channel"], + priority: 3, + category: "engine-boundary", + next: "Test native async continuation and concurrent request isolation. Build-time lowering supports a bounded profile but changes observable Promise behavior; do not classify arbitrary async code as complete.", + evidence: ["engine-boundaries.probe.mjs", "async-transform.probe.mjs"], + }, + { + modules: ["worker_threads"], + priority: 3, + category: "engine-boundary", + next: "Reconcile MessagePort scheduling, trusted event branding and serialization. Native and synthetic ports have different observable behavior; the current adapter does not supply Node threads.", + evidence: ["message-port-boundaries.probe.mjs"], + }, + { + modules: ["stream/web"], + priority: 2, + category: "behavior-gap", + next: "The owned stream implementation now matches tested Workers tee cancellation reasons and pending pipeTo abort timing. Complete the remaining operation/state inventory and native integration acceptance; raw host boundary probes describe host forwarding, not this adapter.", + evidence: ["stream-boundaries.probe.mjs"], + }, + { + modules: ["module"], + priority: 3, + category: "implementation-and-host-integration", + next: "Audit Workers module resolution and loader/stub behavior. VFS JSON loading and bundling are the current limits; separately evaluate executable resolution and engine compile-cache APIs.", + evidence: ["../../../../src/compat/module/index.ts", "surface-gaps.json"], + }, + { + modules: [ + "tls", + "_tls_wrap", + "_stream_wrap", + "_http_common", + "_http_outgoing", + "_http_server", + "http", + "https", + "net", + "_tls_common", + "_http_agent", + "_http_client", + "_http_incoming", + ], + priority: 2, + category: "implementation-and-native-transport", + next: "Audit class/prototype/state/event contracts together with native TCP/TLS behavior. Resolving internal imports or passing Fetch HTTP scenarios does not certify Node TLS/server APIs.", + evidence: ["surface-gaps.json", "../../../../docs/compatibility.md"], + }, + { + modules: ["dns", "dns/promises"], + priority: 2, + category: "behavior-gap", + next: "Verify Workers synthetic Service Binding/Hyperdrive addresses as well as DNS-over-HTTPS and errors; public DNS success does not cover these overrides.", + evidence: ["../../../../docs/compatibility.md"], + }, + { + modules: [ + "child_process", + "cluster", + "dgram", + "vm", + "v8", + "wasi", + "sqlite", + "inspector", + "inspector/promises", + "repl", + "tty", + "trace_events", + ], + priority: 3, + category: "workers-stub-profile", + next: "Audit every operation against the pinned profile, preserving actual rejection/no-op behavior. A module in this group is not necessarily wholly nonfunctional; retained functional methods and validation still require acceptance.", + evidence: [ + "../../../../src/compat/README.md", + "engine-boundaries.probe.mjs", + ], + }, +]; + +export function completionReport(baseline, reports) { + const names = Object.keys(baseline.modules).sort(); + const covered = new Map(); + for (const item of assessments) + for (const name of item.modules) { + assert.ok(names.includes(name), `Unknown assessment module: ${name}`); + assert.ok(!covered.has(name), `Duplicate assessment: ${name}`); + covered.set(name, item); + } + for (const [engine, report] of Object.entries(reports)) { + assert.deepEqual( + report.profile, + baseline.profile, + `${engine}: mismatched Workers profile`, + ); + assert.deepEqual( + Object.keys(report.modules).sort(), + names, + `${engine}: incomplete inventory`, + ); + } + assert.deepEqual(Object.keys(reports).sort(), ["chromium", "webkit"]); + const modules = Object.fromEntries( + names.map((name) => { + const engines = Object.fromEntries( + Object.entries(reports).map(([engine, report]) => { + const value = report.modules[name]; + if (!value.buildError && !value.evaluationError) { + assert.ok( + value.surface && + Array.isArray(value.missing) && + Array.isArray(value.extra), + `${engine}/${name}: missing surface evidence`, + ); + assert.ok( + value.typeMismatches && typeof value.typeMismatches === "object", + `${engine}/${name}: missing type audit`, + ); + } + return [ + engine, + { + missing: value.missing ?? [], + extra: value.extra ?? [], + typeMismatches: value.typeMismatches ?? {}, + ...(value.buildError ? { buildError: value.buildError } : {}), + ...(value.evaluationError + ? { evaluationError: value.evaluationError } + : {}), + }, + ]; + }), + ); + const gaps = Object.values(engines).some( + (value) => + value.buildError || + value.evaluationError || + value.missing.length || + value.extra.length || + Object.keys(value.typeMismatches).length, + ); + const { modules: ignored, ...assessment } = covered.get(name) ?? { + priority: 2, + category: "verification-gap", + next: "Existing contracts and matching exports do not certify a whole module. Finish operation/prototype inventory, invalid inputs, state, cleanup, build integration and iOS/Android acceptance before promotion.", + evidence: ["../../../../src/compat/README.md"], + }; + return [ + name, + { + status: gaps ? "surface-gaps" : "surface-aligned-not-certified", + ...assessment, + engines, + }, + ]; + }), + ); + return { + profile: baseline.profile, + scope: + "Import/export and type audit plus implementation triage. Not whole-module behavioral or native acceptance. Priority is an investigation order, not a feasibility guarantee.", + summary: { + modules: names.length, + withSurfaceGaps: Object.values(modules).filter( + (m) => m.status === "surface-gaps", + ).length, + surfaceAligned: Object.values(modules).filter( + (m) => m.status === "surface-aligned-not-certified", + ).length, + certifiedCompleteByThisAudit: 0, + }, + modules, + }; +} + +if ( + process.argv[1] && + path.resolve(process.argv[1]) === fileURLToPath(import.meta.url) +) { + const read = async (url) => JSON.parse(await readFile(url, "utf8")); + const artifacts = new URL( + "../../../artifacts/node-inventory/", + import.meta.url, + ); + const baseline = await read(new URL("exports.json", import.meta.url)); + const reports = Object.fromEntries( + await Promise.all( + ["chromium", "webkit"].map(async (engine) => [ + engine, + await read(new URL(`${engine}-surface.json`, artifacts)), + ]), + ), + ); + const report = completionReport(baseline, reports); + await writeFile( + new URL("completion.json", artifacts), + JSON.stringify(report, null, 2) + "\n", + ); + console.log(JSON.stringify(report.summary, null, 2)); + console.log( + "Report: demo/artifacts/node-inventory/completion.json; successful generation is not compatibility acceptance.", + ); + if (process.argv.includes("--require-complete")) { + console.error( + "No whole-module certification is supplied by an import/export audit.", + ); + process.exitCode = 1; + } +} diff --git a/demo/tests/experiments/node-compat/completion-report.test.mjs b/demo/tests/experiments/node-compat/completion-report.test.mjs new file mode 100644 index 00000000..0f757c59 --- /dev/null +++ b/demo/tests/experiments/node-compat/completion-report.test.mjs @@ -0,0 +1,78 @@ +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { readFile } from "node:fs/promises"; +import { completionReport } from "./completion-report.mjs"; +const baseline = JSON.parse( + await readFile(new URL("exports.json", import.meta.url), "utf8"), +); +function reports() { + return Object.fromEntries( + ["chromium", "webkit"].map((engine) => [ + engine, + { + profile: structuredClone(baseline.profile), + modules: Object.fromEntries( + Object.keys(baseline.modules).map((name) => [ + name, + { surface: {}, missing: [], extra: [], typeMismatches: {} }, + ]), + ), + }, + ]), + ); +} +test("even exact export alignment cannot certify behavioral/native compatibility", () => { + const result = completionReport(baseline, reports()); + assert.equal( + result.summary.surfaceAligned, + Object.keys(baseline.modules).length, + ); + assert.equal(result.summary.certifiedCompleteByThisAudit, 0); + assert.ok( + Object.values(result.modules).every( + (module) => + module.status === "surface-aligned-not-certified" && + module.next && + module.evidence.length, + ), + ); + assert.equal(result.modules["fs"].category, "implementation-gap"); + assert.equal(result.modules["stream/web"].category, "behavior-gap"); + assert.equal(result.modules["util/types"].category, "engine-boundary"); +}); +test("one engine's missing export, import error or wrong type remains debt", () => { + for (const change of [ + { missing: ["once"] }, + { buildError: ["unresolved"] }, + { evaluationError: { name: "TypeError", message: "broken" } }, + { typeMismatches: { once: { expected: "function", actual: "object" } } }, + ]) { + const input = reports(); + Object.assign(input.webkit.modules.events, change); + const result = completionReport(baseline, input); + assert.equal(result.summary.withSurfaceGaps, 1); + assert.equal(result.modules.events.status, "surface-gaps"); + } +}); +test("missing engines, modules and stale profiles fail rather than disappear", () => { + let input = reports(); + delete input.webkit; + assert.throws(() => completionReport(baseline, input)); + input = reports(); + delete input.webkit.modules.crypto; + assert.throws( + () => completionReport(baseline, input), + /incomplete inventory/, + ); + input = reports(); + input.chromium.profile.workerd = "different"; + assert.throws( + () => completionReport(baseline, input), + /mismatched Workers profile/, + ); +}); +test("old reports without the type audit cannot be promoted as current evidence", () => { + const input = reports(); + delete input.chromium.modules.events.typeMismatches; + assert.throws(() => completionReport(baseline, input), /missing type audit/); +}); diff --git a/demo/tests/experiments/node-compat/events-baseline.probe.mjs b/demo/tests/experiments/node-compat/events-baseline.probe.mjs new file mode 100644 index 00000000..0d06c27a --- /dev/null +++ b/demo/tests/experiments/node-compat/events-baseline.probe.mjs @@ -0,0 +1,56 @@ +import { + observeEvents, + expectedEvents, +} from "../../../../src/compat/events/observations.spec.mjs"; +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { mkdir, readFile, writeFile } from "node:fs/promises"; +import { createRequire } from "node:module"; +import { Miniflare, convertV4MiniflareOptions } from "miniflare"; + +// Pinned Workers observations for the scoped WebView events adapter. +// In particular, do not mistake Node's native EventTarget introspection for the +// behavior of the pinned Workers profile. +test("pin events behavior before implementing missing exports", async () => { + const require = createRequire(import.meta.url); + const mfRequire = createRequire(require.resolve("miniflare/package.json")); + const version = JSON.parse( + await readFile(mfRequire.resolve("workerd/package.json"), "utf8"), + ).version; + assert.equal(version, "1.20261012.1"); + const runtime = new Miniflare( + convertV4MiniflareOptions({ + modules: true, + compatibilityDate: "2026-10-17", + script: `import * as events from 'node:events'; +import { AsyncLocalStorage } from 'node:async_hooks'; +export default { async fetch() { return Response.json(await (${observeEvents.toString()})(events, AsyncLocalStorage)); }};`, + }), + ); + try { + const response = await runtime.dispatchFetch( + "https://events-baseline.invalid/", + ); + assert.equal(response.status, 200); + const result = await response.json(); + assert.deepEqual(result, expectedEvents); + const output = new URL( + "../../../artifacts/node-inventory/", + import.meta.url, + ); + await mkdir(output, { recursive: true }); + await writeFile( + new URL("events-baseline.json", output), + JSON.stringify( + { + profile: { workerd: version, compatibilityDate: "2026-10-17" }, + result, + }, + null, + 2, + ) + "\n", + ); + } finally { + await runtime.dispose(); + } +}); diff --git a/demo/tests/experiments/node-compat/events-contracts.probe.mjs b/demo/tests/experiments/node-compat/events-contracts.probe.mjs new file mode 100644 index 00000000..75fd16fb --- /dev/null +++ b/demo/tests/experiments/node-compat/events-contracts.probe.mjs @@ -0,0 +1,218 @@ +import { build as viteBuild } from "vite"; +import { workersCapacitorPlugin as viteWorkers } from "../../../../dist/tooling/vite.js"; +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { readFile, mkdir, writeFile } from "node:fs/promises"; +import { createRequire } from "node:module"; +import { fileURLToPath } from "node:url"; +import { build } from "esbuild"; +import { chromium, webkit } from "@playwright/test"; +import { Miniflare, convertV4MiniflareOptions } from "miniflare"; +import { workersCapacitorPlugin } from "../../../../dist/tooling/esbuild.js"; +import { eventCases } from "../../../../src/compat/events/index.spec.mjs"; + +const root = fileURLToPath(new URL("../../../..", import.meta.url)); +const profile = JSON.parse( + await readFile(new URL("exports.json", import.meta.url), "utf8"), +).profile; +const require = createRequire(import.meta.url); +const mfRequire = createRequire(require.resolve("miniflare/package.json")); +assert.equal( + JSON.parse(await readFile(mfRequire.resolve("workerd/package.json"), "utf8")) + .version, + profile.workerd, +); +const runtime = new Miniflare( + convertV4MiniflareOptions({ + modules: true, + compatibilityDate: profile.compatibilityDate, + script: `import * as events from 'node:events'; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +const cases = {${Object.entries(eventCases) + .map(([name, fn]) => `${JSON.stringify(name)}: (${fn.toString()})`) + .join(",")}}; +export default {async fetch(request) { + const name = new URL(request.url).pathname.slice(1); + return Response.json(await cases[name]({events, AsyncLocalStorage, process})); +}};`, + }), +); +const baseline = {}; +try { + for (const name of Object.keys(eventCases)) { + const response = await runtime.dispatchFetch( + `https://events.invalid/${name}`, + ); + assert.equal(response.status, 200, name); + baseline[name] = await response.json(); + } +} finally { + await runtime.dispose(); +} +const output = new URL("../../../artifacts/node-inventory/", import.meta.url); +await mkdir(output, { recursive: true }); +await writeFile( + new URL("events-contracts-workerd.json", output), + JSON.stringify({ profile, results: baseline }, null, 2) + "\n", +); +const compiled = await build({ + absWorkingDir: root, + stdin: { + resolveDir: root, + contents: `import * as events from 'node:events'; +import { eventCases } from './src/compat/events/index.spec.mjs'; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +export const run = name => eventCases[name]({events, AsyncLocalStorage, process});`, + }, + bundle: true, + platform: "browser", + format: "esm", + write: false, + outfile: "demo/artifacts/node-inventory/events-contracts.js", + plugins: [ + workersCapacitorPlugin({ + execution: "local", + worker: "demo/src/workers/hono/standard.ts", + }), + ], +}); +const entry = fileURLToPath(new URL("events-vite-entry.mjs", output)); +await writeFile( + entry, + `import * as events from ${JSON.stringify("node:events")}; +import { eventCases } from ${JSON.stringify(fileURLToPath(new URL("../../../../src/compat/events/index.spec.mjs", import.meta.url)))}; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +export const run = name => eventCases[name]({events, AsyncLocalStorage, process});`, +); +const viteResult = await viteBuild({ + configFile: false, + root, + logLevel: "error", + plugins: [ + viteWorkers({ + execution: "local", + worker: "demo/src/workers/hono/standard.ts", + }), + ], + build: { + write: false, + minify: false, + rollupOptions: { + input: entry, + preserveEntrySignatures: "strict", + output: { inlineDynamicImports: true }, + }, + }, +}); +const viteChunk = viteResult.output.find( + (item) => item.type === "chunk" && item.isEntry, +); +assert.ok(viteChunk); +for (const [builder, source] of Object.entries({ + esbuild: compiled.outputFiles[0].text, + vite: viteChunk.code, +})) { + for (const [engine, launcher] of Object.entries({ chromium, webkit })) { + for (const mode of ["page", "worker"]) { + test(`${builder}/${engine}/${mode}: events contracts through public imports`, async (t) => { + const browser = await launcher.launch(); + const results = {}; + try { + for (const name of Object.keys(eventCases)) { + await t.test(name, { timeout: 15000 }, async () => { + const page = await browser.newPage(); + await page.route("http://events.test/", (route) => + route.fulfill({ + contentType: "text/html", + body: "Events contracts", + }), + ); + await page.goto("http://events.test/"); + try { + const result = await page.evaluate( + async ({ source, name, mode }) => { + const url = URL.createObjectURL( + new Blob([source], { type: "text/javascript" }), + ); + try { + if (mode === "page") { + const api = await import(url); + return JSON.parse(JSON.stringify(await api.run(name))); + } + const workerUrl = URL.createObjectURL( + new Blob( + [ + `import { run } from ${JSON.stringify(url)};\nself.onmessage = async ({data}) => { try { self.postMessage({value: JSON.parse(JSON.stringify(await run(data)))}); } catch (error) { self.postMessage({error: String(error)}); } };`, + ], + { type: "text/javascript" }, + ), + ); + const worker = new Worker(workerUrl, { type: "module" }); + try { + return await new Promise((resolve, reject) => { + const timer = setTimeout( + () => + reject(new Error("Worker operation timed out")), + 8000, + ); + worker.onerror = (event) => { + clearTimeout(timer); + reject(new Error(event.message)); + }; + worker.onmessage = ({ data }) => { + clearTimeout(timer); + data.error + ? reject(new Error(data.error)) + : resolve(data.value); + }; + worker.postMessage(name); + }); + } finally { + worker.terminate(); + URL.revokeObjectURL(workerUrl); + } + } finally { + URL.revokeObjectURL(url); + } + }, + { source, name, mode }, + ); + results[name] = result; + assert.deepEqual(result, baseline[name]); + } finally { + await page.close(); + } + }); + } + } finally { + await browser.close(); + await writeFile( + new URL( + `events-contracts-${builder}-${engine}-${mode}.json`, + output, + ), + JSON.stringify( + { + profile, + builder, + engine, + mode, + status: "webview-profile-operation-contracts", + knownGaps: { + process: + "existing partial process profile; native stack inspection remains engine-dependent", + }, + results, + }, + null, + 2, + ) + "\n", + ); + } + }); + } + } +} diff --git a/demo/tests/experiments/node-compat/events-native.mjs b/demo/tests/experiments/node-compat/events-native.mjs new file mode 100644 index 00000000..d4b0079a --- /dev/null +++ b/demo/tests/experiments/node-compat/events-native.mjs @@ -0,0 +1,254 @@ +import { execFileSync } from "node:child_process"; +import assert from "node:assert/strict"; +import { readFile, mkdir, writeFile } from "node:fs/promises"; +import { fileURLToPath, pathToFileURL } from "node:url"; +import { createHash } from "node:crypto"; +import { build } from "esbuild"; + +import { eventCases } from "../../../../src/compat/events/index.spec.mjs"; +import { nativeBackend } from "../../native/backend.mjs"; +import { runNativeAcceptance } from "../../native/acceptance.mjs"; +const [platform, device] = process.argv.slice(2); +assert.ok( + ["ios", "android"].includes(platform) && device, + "Usage: node events-native.mjs ios|android ", +); +const root = fileURLToPath(new URL("../../../..", import.meta.url)); +const baseline = JSON.parse( + await readFile( + new URL( + "../../../artifacts/node-inventory/events-contracts-workerd.json", + import.meta.url, + ), + "utf8", + ), +); +const profile = JSON.parse( + await readFile(new URL("exports.json", import.meta.url), "utf8"), +).profile; +assert.deepEqual(baseline.profile, profile); +assert.deepEqual(Object.keys(baseline.results), Object.keys(eventCases)); +const artifacts = fileURLToPath( + new URL( + `../../../artifacts/node-inventory/native-events/${platform}/`, + import.meta.url, + ), +); +await mkdir(artifacts, { recursive: true }); +await mkdir(`${artifacts}/public`, { recursive: true }); +await writeFile( + `${artifacts}/public/index.html`, + "Events native fixture", +); +await writeFile( + `${artifacts}/worker.ts`, + 'export default {fetch() {return new Response("Events fixture");}};', +); +await writeFile( + `${artifacts}/wrangler.json`, + JSON.stringify({ + name: "events-native-fixture", + main: "worker.ts", + compatibility_date: profile.compatibilityDate, + assets: { directory: "./public", binding: "ASSETS" }, + }), +); +await mkdir(`${artifacts}/local`, { recursive: true }); +await writeFile( + `${artifacts}/local/worker.ts`, + 'export default {fetch() {return new Response("Events local fixture");}};', +); +await writeFile( + `${artifacts}/local/wrangler.json`, + JSON.stringify({ + name: "events-local-fixture", + main: "worker.ts", + compatibility_date: profile.compatibilityDate, + }), +); +const { consumer, tarball, tarballSha256 } = JSON.parse( + await readFile( + new URL( + "../../../artifacts/node-inventory/events-consumer.json", + import.meta.url, + ), + "utf8", + ), +); +const { workersCapacitorPlugin } = await import( + pathToFileURL( + `${consumer}/node_modules/cf-workers-native/dist/tooling/esbuild.js`, + ).href +); +const compiled = await build({ + absWorkingDir: consumer, + stdin: { + resolveDir: consumer, + contents: `import * as events from 'node:events'; +import { eventCases } from ${JSON.stringify(root + "/src/compat/events/index.spec.mjs")}; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +export const run = name => eventCases[name]({events, AsyncLocalStorage, process});`, + }, + bundle: true, + platform: "browser", + format: "esm", + write: false, + outfile: `${artifacts}/candidate.js`, + plugins: [ + workersCapacitorPlugin({ + execution: "local", + worker: `${artifacts}/local/worker.ts`, + workerConfig: `${artifacts}/local/wrangler.json`, + }), + ], +}); +const source = compiled.outputFiles[0].text; +const hash = createHash("sha256").update(source).digest("hex"); +await writeFile(`${artifacts}/candidate.js`, source); +await writeFile( + `${artifacts}/inputs.json`, + JSON.stringify( + { + profile, + hash, + platform, + device, + tarball, + tarballSha256, + cases: Object.keys(eventCases), + }, + null, + 2, + ), +); +// Allow emulator clock drift without disabling TLS verification. +const tlsDirectory = `${artifacts}/tls`; +await mkdir(tlsDirectory, { recursive: true }); +await writeFile(`${tlsDirectory}/index`, ""); +await writeFile(`${tlsDirectory}/serial`, "01\n"); +await writeFile( + `${tlsDirectory}/ca.cnf`, + `[ca] +default_ca=local +[local] +database=${tlsDirectory}/index +new_certs_dir=${tlsDirectory} +serial=${tlsDirectory}/serial +private_key=${tlsDirectory}/key.pem +default_md=sha256 +policy=policy +x509_extensions=extensions +[policy] +commonName=supplied +[extensions] +subjectAltName=DNS:localhost,IP:127.0.0.1 +basicConstraints=critical,CA:TRUE +`, +); +execFileSync( + "openssl", + [ + "req", + "-new", + "-newkey", + "rsa:2048", + "-nodes", + "-keyout", + `${tlsDirectory}/key.pem`, + "-out", + `${tlsDirectory}/request.pem`, + "-subj", + "/CN=Events native acceptance", + ], + { stdio: "pipe" }, +); +const certificateTime = (time) => + new Date(time) + .toISOString() + .replace(/[-:]/g, "") + .replace(/T/, "") + .slice(0, 14) + "Z"; +execFileSync( + "openssl", + [ + "ca", + "-batch", + "-selfsign", + "-config", + `${tlsDirectory}/ca.cnf`, + "-in", + `${tlsDirectory}/request.pem`, + "-out", + `${tlsDirectory}/ca.pem`, + "-startdate", + certificateTime(Date.now() - 86400000), + "-enddate", + certificateTime(Date.now() + 172800000), + ], + { stdio: "pipe" }, +); +const backend = await nativeBackend({ + tlsDirectory, + dispatch: async () => new Response("Not found", { status: 404 }), + driver: "", + dispose: async () => {}, + instrument: () => false, +}); +const bootstrapCode = ` +async function main() { +const source = ${JSON.stringify(source)}; +const names = ${JSON.stringify(Object.keys(eventCases))}; +const report = async value => {await fetch(${JSON.stringify(backend.url.origin + "/__acceptance/report")}, {method:'POST', mode:'no-cors', headers:{'content-type':'text/plain'}, body:JSON.stringify(value)});}; +const results = {}; +try { + for (const mode of ['page', 'worker']) { + results[mode] = {}; + for (const name of names) { + const url = URL.createObjectURL(new Blob([source], {type:'text/javascript'})); + try { + if (mode === 'page') { const api = await import(/* @vite-ignore */ url); results[mode][name] = JSON.parse(JSON.stringify(await api.run(name))); } + else { + const workerURL = URL.createObjectURL(new Blob(['import {run} from ' + JSON.stringify(url) + '; self.onmessage = async ({data}) => {try {self.postMessage({value:JSON.parse(JSON.stringify(await run(data)))});} catch(error) {self.postMessage({error:String(error)});}};'], {type:'text/javascript'})); + const worker = new Worker(workerURL, {type:'module'}); + try { + results[mode][name] = await new Promise((resolve,reject) => { + const timer = setTimeout(() => reject(new Error('Worker timeout: '+name)), 8000); + worker.onmessage = ({data}) => {clearTimeout(timer); data.error ? reject(new Error(data.error)) : resolve(data.value);}; + worker.onerror = event => {clearTimeout(timer);reject(new Error(event.message || 'Worker error'));}; + worker.postMessage(name); + }); + } finally {worker.terminate(); URL.revokeObjectURL(workerURL);} + } + } finally {URL.revokeObjectURL(url);} + } + } + await report({stage:'complete', hash:${JSON.stringify(hash)}, results}); + document.body.textContent = 'Events contracts complete'; +} catch(error) {await report({stage:'failure', message:String(error), stack:error.stack});document.body.textContent=String(error);} +} +main(); +`; +await runNativeAcceptance({ + backend, + artifacts, + platform, + device, + bootstrapCode, + shell: consumer, + appId: "jp.rdlabo.workerscapacitor.events", + worker: `${artifacts}/worker.ts`, + workerConfig: `${artifacts}/wrangler.json`, + validate: async (backend) => { + const completed = backend.reports.find( + (report) => report.stage === "complete", + ); + assert.equal(completed.hash, hash); + assert.deepEqual(Object.keys(completed.results).sort(), ["page", "worker"]); + for (const mode of ["page", "worker"]) + assert.deepEqual(completed.results[mode], baseline.results); + }, +}); +console.log( + `${platform}: ${Object.keys(eventCases).length} operation groups passed in page and Dedicated Worker (${hash})`, +); diff --git a/demo/tests/experiments/node-compat/events-surface.probe.mjs b/demo/tests/experiments/node-compat/events-surface.probe.mjs new file mode 100644 index 00000000..6617314e --- /dev/null +++ b/demo/tests/experiments/node-compat/events-surface.probe.mjs @@ -0,0 +1,115 @@ +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { readFile, mkdir, writeFile } from "node:fs/promises"; +import { fileURLToPath } from "node:url"; +import { build } from "esbuild"; +import { chromium, webkit } from "@playwright/test"; +import { workersCapacitorPlugin } from "../../../../dist/tooling/esbuild.js"; +import { lowerAsync } from "../../../../dist/tooling/async.js"; +import { expectedEvents } from "../../../../src/compat/events/observations.spec.mjs"; + +// Public imports and selected observations for the scoped WebView profile. +// Native acceptance and broader operation contracts have separate runners. +const root = fileURLToPath(new URL("../../../..", import.meta.url)); +const expectedTypes = JSON.parse( + await readFile(new URL("export-types.json", import.meta.url), "utf8"), +).modules.events; +const compiled = await build({ + absWorkingDir: root, + stdin: { + contents: `import * as events from 'node:events'; +import { observeEvents } from './src/compat/events/observations.spec.mjs'; +import { AsyncLocalStorage } from 'node:async_hooks'; +export const surface = Object.fromEntries(Object.entries(events).map(([key, value]) => [key, typeof value])); +export const observe = () => observeEvents(events, AsyncLocalStorage);`, + resolveDir: root, + }, + bundle: true, + platform: "browser", + format: "esm", + write: false, + outfile: "demo/artifacts/node-inventory/events-surface.js", + plugins: [ + workersCapacitorPlugin({ + execution: "local", + worker: "demo/src/workers/hono/standard.ts", + }), + ], +}); +for (const [engine, launcher] of Object.entries({ chromium, webkit })) { + test(`${engine}: public events matches selected pinned Workers observations`, async () => { + const browser = await launcher.launch(); + try { + const page = await browser.newPage(); + const result = await page.evaluate(async (source) => { + const url = URL.createObjectURL( + new Blob([source], { type: "text/javascript" }), + ); + try { + const api = await import(url); + return { surface: api.surface, observations: await api.observe() }; + } finally { + URL.revokeObjectURL(url); + } + }, compiled.outputFiles[0].text); + assert.deepEqual(result.surface, expectedTypes); + assert.deepEqual(result.observations, expectedEvents); + const output = new URL( + "../../../artifacts/node-inventory/", + import.meta.url, + ); + await mkdir(output, { recursive: true }); + await writeFile( + new URL(`events-surface-${engine}.json`, output), + JSON.stringify( + { engine, status: "selected-observations-only", ...result }, + null, + 2, + ) + "\n", + ); + } finally { + await browser.close(); + } + }); +} + +// Ordinary build lowering must preserve the native intrinsic without exemptions. +const intrinsicSource = await readFile( + new URL("../../../../src/compat/events/intrinsics.ts", import.meta.url), + "utf8", +); +const loweredIntrinsic = await lowerAsync( + intrinsicSource, + "intrinsics.mjs", + "js", +); +for (const [engine, launcher] of Object.entries({ chromium, webkit })) { + test(`${engine}: ordinary async lowering preserves native iterator intrinsic discovery`, async () => { + const browser = await launcher.launch(); + try { + const page = await browser.newPage(); + const observe = (source) => + page.evaluate(async (code) => { + const url = URL.createObjectURL( + new Blob([code], { type: "text/javascript" }), + ); + try { + const api = await import(url); + return { + type: typeof api.AsyncIteratorPrototype[Symbol.asyncIterator], + }; + } catch (error) { + return { error: error.name }; + } finally { + URL.revokeObjectURL(url); + } + }, source); + assert.deepEqual(await observe(intrinsicSource), { type: "function" }); + assert.deepEqual(await observe(loweredIntrinsic.code), { + type: "function", + }); + } finally { + await browser.close(); + } + }); +} diff --git a/demo/tests/experiments/node-compat/expansion-contracts.probe.mjs b/demo/tests/experiments/node-compat/expansion-contracts.probe.mjs new file mode 100644 index 00000000..66b0dbdf --- /dev/null +++ b/demo/tests/experiments/node-compat/expansion-contracts.probe.mjs @@ -0,0 +1,223 @@ +import { build as viteBuild } from "vite"; +import { workersCapacitorPlugin as viteWorkers } from "../../../../dist/tooling/vite.js"; +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { readFile, mkdir, writeFile } from "node:fs/promises"; +import { createRequire } from "node:module"; +import { fileURLToPath } from "node:url"; +import { build } from "esbuild"; +import { chromium, webkit } from "@playwright/test"; +import { Miniflare, convertV4MiniflareOptions } from "miniflare"; +import { workersCapacitorPlugin } from "../../../../dist/tooling/esbuild.js"; +import { eventCases } from "../../../../src/compat/expansion/index.spec.mjs"; + +const root = fileURLToPath(new URL("../../../..", import.meta.url)); +const profile = JSON.parse( + await readFile(new URL("exports.json", import.meta.url), "utf8"), +).profile; +const require = createRequire(import.meta.url); +const mfRequire = createRequire(require.resolve("miniflare/package.json")); +assert.equal( + JSON.parse(await readFile(mfRequire.resolve("workerd/package.json"), "utf8")) + .version, + profile.workerd, +); +const runtime = new Miniflare( + convertV4MiniflareOptions({ + modules: true, + compatibilityDate: profile.compatibilityDate, + script: `import * as tls from 'node:tls'; import * as streams from 'node:stream/web'; import * as module from 'node:module'; import * as httpCommon from 'node:_http_common'; import * as httpOutgoing from 'node:_http_outgoing'; import * as httpServer from 'node:_http_server'; import * as http from 'node:http'; import * as fs from 'node:fs'; import * as zlib from 'node:zlib'; import * as sys from 'node:sys'; import * as util from 'node:util'; import * as types from 'node:util/types'; import * as console from 'node:console'; import * as crypto from 'node:crypto'; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +const cases = {${Object.entries(eventCases) + .map(([name, fn]) => `${JSON.stringify(name)}: (${fn.toString()})`) + .join(",")}}; +export default {async fetch(request) { + const name = new URL(request.url).pathname.slice(1); + return Response.json(await cases[name]({process, tls, streams, sys, util, types, console, crypto, fs, zlib, module, httpCommon, httpOutgoing, httpServer, http})); +}};`, + }), +); +const baseline = {}; +try { + for (const name of Object.keys(eventCases)) { + const response = await runtime.dispatchFetch( + `https://events.invalid/${name}`, + ); + assert.equal( + response.status, + 200, + response.status === 200 ? name : `${name}: ${await response.text()}`, + ); + baseline[name] = await response.json(); + } +} finally { + await runtime.dispose(); +} +const output = new URL("../../../artifacts/node-inventory/", import.meta.url); +await mkdir(output, { recursive: true }); +await writeFile( + new URL("expansion-contracts-workerd.json", output), + JSON.stringify({ profile, results: baseline }, null, 2) + "\n", +); +const compiled = await build({ + absWorkingDir: root, + stdin: { + resolveDir: root, + contents: `import * as tls from 'node:tls'; import * as streams from 'node:stream/web'; import * as module from 'node:module'; import * as httpCommon from 'node:_http_common'; import * as httpOutgoing from 'node:_http_outgoing'; import * as httpServer from 'node:_http_server'; import * as http from 'node:http'; import * as fs from 'node:fs'; import * as zlib from 'node:zlib'; import * as sys from 'node:sys'; import * as util from 'node:util'; import * as types from 'node:util/types'; import * as console from 'node:console'; import * as crypto from 'node:crypto'; +import { eventCases } from './src/compat/expansion/index.spec.mjs'; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +export const run = name => eventCases[name]({process, tls, streams, sys, util, types, console, crypto, fs, zlib, module, httpCommon, httpOutgoing, httpServer, http});`, + }, + bundle: true, + platform: "browser", + format: "esm", + write: false, + outfile: "demo/artifacts/node-inventory/expansion-contracts.js", + plugins: [ + workersCapacitorPlugin({ + execution: "local", + worker: "demo/src/workers/hono/standard.ts", + }), + ], +}); +const entry = fileURLToPath(new URL("expansion-vite-entry.mjs", output)); +await writeFile( + entry, + `import * as tls from 'node:tls'; import * as streams from 'node:stream/web'; import * as module from 'node:module'; import * as httpCommon from 'node:_http_common'; import * as httpOutgoing from 'node:_http_outgoing'; import * as httpServer from 'node:_http_server'; import * as http from 'node:http'; import * as fs from 'node:fs'; import * as zlib from 'node:zlib'; import * as sys from 'node:sys'; import * as util from 'node:util'; import * as types from 'node:util/types'; import * as console from 'node:console'; import * as crypto from 'node:crypto'; +import { eventCases } from ${JSON.stringify(fileURLToPath(new URL("../../../../src/compat/expansion/index.spec.mjs", import.meta.url)))}; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +export const run = name => eventCases[name]({process, tls, streams, sys, util, types, console, crypto, fs, zlib, module, httpCommon, httpOutgoing, httpServer, http});`, +); +const viteResult = await viteBuild({ + configFile: false, + root, + logLevel: "error", + plugins: [ + viteWorkers({ + execution: "local", + worker: "demo/src/workers/hono/standard.ts", + }), + ], + build: { + write: false, + minify: false, + rollupOptions: { + input: entry, + preserveEntrySignatures: "strict", + output: { inlineDynamicImports: true }, + }, + }, +}); +const viteChunk = viteResult.output.find( + (item) => item.type === "chunk" && item.isEntry, +); +assert.ok(viteChunk); +await writeFile(new URL("expansion-vite.js", output), viteChunk.code); +for (const [builder, source] of Object.entries({ + esbuild: compiled.outputFiles[0].text, + vite: viteChunk.code, +})) { + for (const [engine, launcher] of Object.entries({ chromium, webkit })) { + for (const mode of ["page", "worker"]) { + test(`${builder}/${engine}/${mode}: events contracts through public imports`, async (t) => { + const browser = await launcher.launch(); + const results = {}; + try { + for (const name of Object.keys(eventCases)) { + await t.test(name, { timeout: 15000 }, async () => { + const page = await browser.newPage(); + await page.route("http://localhost/", (route) => + route.fulfill({ + contentType: "text/html", + body: "Events contracts", + }), + ); + await page.goto("http://localhost/"); + try { + const result = await page.evaluate( + async ({ source, name, mode }) => { + const url = URL.createObjectURL( + new Blob([source], { type: "text/javascript" }), + ); + try { + if (mode === "page") { + const api = await import(url); + return JSON.parse(JSON.stringify(await api.run(name))); + } + const workerUrl = URL.createObjectURL( + new Blob( + [ + `import { run } from ${JSON.stringify(url)};\nself.onmessage = async ({data}) => { try { self.postMessage({value: JSON.parse(JSON.stringify(await run(data)))}); } catch (error) { self.postMessage({error: String(error)}); } };`, + ], + { type: "text/javascript" }, + ), + ); + const worker = new Worker(workerUrl, { type: "module" }); + try { + return await new Promise((resolve, reject) => { + const timer = setTimeout( + () => + reject(new Error("Worker operation timed out")), + 8000, + ); + worker.onerror = (event) => { + clearTimeout(timer); + reject(new Error(event.message)); + }; + worker.onmessage = ({ data }) => { + clearTimeout(timer); + data.error + ? reject(new Error(data.error)) + : resolve(data.value); + }; + worker.postMessage(name); + }); + } finally { + worker.terminate(); + URL.revokeObjectURL(workerUrl); + } + } finally { + URL.revokeObjectURL(url); + } + }, + { source, name, mode }, + ); + results[name] = result; + assert.deepEqual(result, baseline[name]); + } finally { + await page.close(); + } + }); + } + } finally { + await browser.close(); + await writeFile( + new URL( + `expansion-contracts-${builder}-${engine}-${mode}.json`, + output, + ), + JSON.stringify( + { + profile, + builder, + engine, + mode, + status: "webview-profile-operation-contracts", + knownGaps: { + process: + "existing partial process profile; native stack inspection remains engine-dependent", + }, + results, + }, + null, + 2, + ) + "\n", + ); + } + }); + } + } +} diff --git a/demo/tests/experiments/node-compat/expansion-native.mjs b/demo/tests/experiments/node-compat/expansion-native.mjs new file mode 100644 index 00000000..49d3c9d6 --- /dev/null +++ b/demo/tests/experiments/node-compat/expansion-native.mjs @@ -0,0 +1,294 @@ +import { execFileSync } from "node:child_process"; +import assert from "node:assert/strict"; +import { readFile, mkdir, writeFile } from "node:fs/promises"; +import { fileURLToPath, pathToFileURL } from "node:url"; +import { createHash } from "node:crypto"; +import { build } from "esbuild"; + +import { eventCases } from "../../../../src/compat/expansion/index.spec.mjs"; +import { nativeBackend } from "../../native/backend.mjs"; +import { runNativeAcceptance } from "../../native/acceptance.mjs"; +const [platform, device] = process.argv.slice(2); +assert.ok( + ["ios", "android"].includes(platform) && device, + "Usage: node expansion-native.mjs ios|android ", +); +const root = fileURLToPath(new URL("../../../..", import.meta.url)); +const baseline = JSON.parse( + await readFile( + new URL( + "../../../artifacts/node-inventory/expansion-contracts-workerd.json", + import.meta.url, + ), + "utf8", + ), +); +const profile = JSON.parse( + await readFile(new URL("exports.json", import.meta.url), "utf8"), +).profile; +assert.deepEqual(baseline.profile, profile); +assert.deepEqual(Object.keys(baseline.results), Object.keys(eventCases)); +const artifacts = fileURLToPath( + new URL( + `../../../artifacts/node-inventory/native-expansion/${platform}/`, + import.meta.url, + ), +); +await mkdir(artifacts, { recursive: true }); +await mkdir(`${artifacts}/public`, { recursive: true }); +await writeFile( + `${artifacts}/public/index.html`, + "Compatibility expansion fixture", +); +await writeFile( + `${artifacts}/worker.ts`, + 'export default {fetch() {return new Response("Compatibility fixture");}};', +); +await writeFile( + `${artifacts}/wrangler.json`, + JSON.stringify({ + name: "events-native-fixture", + main: "worker.ts", + compatibility_date: profile.compatibilityDate, + assets: { directory: "./public", binding: "ASSETS" }, + }), +); +await mkdir(`${artifacts}/local`, { recursive: true }); +await writeFile( + `${artifacts}/local/worker.ts`, + 'export default {fetch() {return new Response("Events local fixture");}};', +); +await writeFile( + `${artifacts}/local/wrangler.json`, + JSON.stringify({ + name: "events-local-fixture", + main: "worker.ts", + compatibility_date: profile.compatibilityDate, + }), +); +const { consumer, tarball, tarballSha256 } = JSON.parse( + await readFile( + new URL( + "../../../artifacts/node-inventory/events-consumer.json", + import.meta.url, + ), + "utf8", + ), +); +const { workersCapacitorPlugin } = await import( + pathToFileURL( + `${consumer}/node_modules/cf-workers-native/dist/tooling/esbuild.js`, + ).href +); +const compiled = await build({ + absWorkingDir: consumer, + stdin: { + resolveDir: consumer, + contents: `import * as net from 'node:net'; import * as tls from 'node:tls'; import * as streams from 'node:stream/web'; import * as module from 'node:module'; import * as httpCommon from 'node:_http_common'; import * as httpOutgoing from 'node:_http_outgoing'; import * as httpServer from 'node:_http_server'; import * as http from 'node:http'; import * as fs from 'node:fs'; import * as zlib from 'node:zlib'; import * as sys from 'node:sys'; import * as util from 'node:util'; import * as types from 'node:util/types'; import * as console from 'node:console'; import * as crypto from 'node:crypto'; +import { eventCases } from ${JSON.stringify(root + "/src/compat/expansion/index.spec.mjs")}; +import { AsyncLocalStorage } from 'node:async_hooks'; +import process from 'node:process'; +export const run = name => eventCases[name]({process, tls, streams, sys, util, types, console, crypto, fs, zlib, module, httpCommon, httpOutgoing, httpServer, http}); +export {createNetworkRelay, initializeWorkerNetwork} from ${JSON.stringify(consumer + "/node_modules/cf-workers-native/dist/browser/fetch/relay.js")}; +export const runTls = async port => { + const attempt = servername => new Promise((resolve,reject)=> { + let accepted=false, body=''; + const socket=tls.connect({host:'127.0.0.1',port,servername}); + const timer=setTimeout(()=>{socket.destroy();reject(new Error('TLS timeout: '+servername));},8000); + socket.on('secureConnect',()=>{accepted=socket.authorized && socket.encrypted;socket.write('GET /tls-native HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n');}); + socket.on('data',chunk=>{body+=chunk.toString();}); + socket.on('error',()=>{clearTimeout(timer);resolve({accepted,received:false});}); + socket.on('end',()=>{clearTimeout(timer);resolve({accepted,received:body.includes('404') && body.includes('Not found')});}); + }); + const valid=await attempt('localhost'), invalid=await attempt('wrong.invalid'); + const plain=net.connect({host:'127.0.0.1',port}); + plain.on('error',()=>{}); + let upgradeRejected=false; + try { + await new Promise((resolve,reject)=>{plain.once('connect',resolve);plain.once('error',reject);}); + try {tls.connect({socket:plain,servername:'localhost'}).write('must-never-be-plaintext');} + catch(error){if(error.code!=='ERR_METHOD_NOT_IMPLEMENTED')throw error;upgradeRejected=true;} + } finally {plain.destroy();} + return {valid,invalid,upgradeRejected}; +};`, + }, + bundle: true, + platform: "browser", + format: "esm", + write: false, + outfile: `${artifacts}/candidate.js`, + plugins: [ + workersCapacitorPlugin({ + execution: "local", + worker: `${artifacts}/local/worker.ts`, + workerConfig: `${artifacts}/local/wrangler.json`, + }), + ], +}); +const source = compiled.outputFiles[0].text; +const hash = createHash("sha256").update(source).digest("hex"); +await writeFile(`${artifacts}/candidate.js`, source); +await writeFile( + `${artifacts}/inputs.json`, + JSON.stringify( + { + profile, + hash, + platform, + device, + tarball, + tarballSha256, + cases: Object.keys(eventCases), + }, + null, + 2, + ), +); +// Allow emulator clock drift without disabling TLS verification. +const tlsDirectory = `${artifacts}/tls`; +await mkdir(tlsDirectory, { recursive: true }); +await writeFile(`${tlsDirectory}/index`, ""); +await writeFile(`${tlsDirectory}/serial`, "01\n"); +await writeFile( + `${tlsDirectory}/ca.cnf`, + `[ca] +default_ca=local +[local] +database=${tlsDirectory}/index +new_certs_dir=${tlsDirectory} +serial=${tlsDirectory}/serial +private_key=${tlsDirectory}/key.pem +default_md=sha256 +policy=policy +x509_extensions=extensions +[policy] +commonName=supplied +[extensions] +subjectAltName=DNS:localhost,IP:127.0.0.1 +basicConstraints=critical,CA:TRUE +`, +); +execFileSync( + "openssl", + [ + "req", + "-new", + "-newkey", + "rsa:2048", + "-nodes", + "-keyout", + `${tlsDirectory}/key.pem`, + "-out", + `${tlsDirectory}/request.pem`, + "-subj", + "/CN=Compatibility expansion acceptance", + ], + { stdio: "pipe" }, +); +const certificateTime = (time) => + new Date(time) + .toISOString() + .replace(/[-:]/g, "") + .replace(/T/, "") + .slice(0, 14) + "Z"; +execFileSync( + "openssl", + [ + "ca", + "-batch", + "-selfsign", + "-config", + `${tlsDirectory}/ca.cnf`, + "-in", + `${tlsDirectory}/request.pem`, + "-out", + `${tlsDirectory}/ca.pem`, + "-startdate", + certificateTime(Date.now() - 86400000), + "-enddate", + certificateTime(Date.now() + 172800000), + ], + { stdio: "pipe" }, +); +const backend = await nativeBackend({ + tlsDirectory, + dispatch: async () => new Response("Not found", { status: 404 }), + driver: "", + dispose: async () => {}, + instrument: () => false, +}); +const bootstrapCode = ` +async function main() { +const source = ${JSON.stringify(source)}; +const names = ${JSON.stringify(Object.keys(eventCases))}; +const report = async value => {await fetch(${JSON.stringify(backend.url.origin + "/__acceptance/report")}, {method:'POST', mode:'no-cors', headers:{'content-type':'text/plain'}, body:JSON.stringify(value)});}; +const results = {}; +try { + for (const mode of ['page', 'worker']) { + results[mode] = {}; + for (const name of names) { + const url = URL.createObjectURL(new Blob([source], {type:'text/javascript'})); + try { + if (mode === 'page') { const api = await import(/* @vite-ignore */ url); results[mode][name] = JSON.parse(JSON.stringify(await api.run(name))); } + else { + const workerURL = URL.createObjectURL(new Blob(['import {run} from ' + JSON.stringify(url) + '; self.onmessage = async ({data}) => {try {self.postMessage({value:JSON.parse(JSON.stringify(await run(data)))});} catch(error) {self.postMessage({error:String(error)});}};'], {type:'text/javascript'})); + const worker = new Worker(workerURL, {type:'module'}); + try { + results[mode][name] = await new Promise((resolve,reject) => { + const timer = setTimeout(() => reject(new Error('Worker timeout: '+name)), 8000); + worker.onmessage = ({data}) => {clearTimeout(timer); data.error ? reject(new Error(data.error)) : resolve(data.value);}; + worker.onerror = event => {clearTimeout(timer);reject(new Error(event.message || 'Worker error'));}; + worker.postMessage(name); + }); + } finally {worker.terminate(); URL.revokeObjectURL(workerURL);} + } + } finally {URL.revokeObjectURL(url);} + } + } + const tlsURL=URL.createObjectURL(new Blob([source],{type:'text/javascript'})); + const tlsApi=await import(/* @vite-ignore */ tlsURL); + const nativeTls={page:await tlsApi.runTls(${JSON.stringify(Number(backend.url.port))})}; + const workerURL=URL.createObjectURL(new Blob(['import {runTls, initializeWorkerNetwork} from '+JSON.stringify(tlsURL)+'; self.onmessage=async ({data})=>{try {await initializeWorkerNetwork();self.postMessage({tls:await runTls(data)});}catch(e){self.postMessage({error:String(e)});}};'],{type:'text/javascript'})); + const tlsWorker=new Worker(workerURL,{type:'module'}); + const relay=tlsApi.createNetworkRelay(tlsWorker); + tlsWorker.addEventListener('message',relay.receive); + try {nativeTls.worker=await new Promise((resolve,reject)=>{ + const timer=setTimeout(()=>reject(new Error('Worker TLS timeout')),20000); + tlsWorker.onmessage=({data})=>{if(data.tls || data.error){clearTimeout(timer);data.error?reject(new Error(data.error)):resolve(data.tls);}}; + tlsWorker.postMessage(${JSON.stringify(Number(backend.url.port))}); + });} finally {tlsWorker.terminate();await relay.dispose();URL.revokeObjectURL(workerURL);URL.revokeObjectURL(tlsURL);} + await report({stage:'complete', nativeTls, hash:${JSON.stringify(hash)}, results}); + document.body.textContent = 'Compatibility contracts complete'; +} catch(error) {await report({stage:'failure', message:String(error), stack:error.stack});document.body.textContent=String(error);} +} +main(); +`; +await runNativeAcceptance({ + backend, + artifacts, + platform, + device, + bootstrapCode, + shell: consumer, + appId: "jp.rdlabo.workerscapacitor.events", + worker: `${artifacts}/worker.ts`, + workerConfig: `${artifacts}/wrangler.json`, + validate: async (backend) => { + const completed = backend.reports.find( + (report) => report.stage === "complete", + ); + assert.equal(completed.hash, hash); + for (const mode of ["page", "worker"]) + assert.deepEqual(completed.nativeTls[mode], { + valid: { accepted: true, received: true }, + invalid: { accepted: false, received: false }, + upgradeRejected: true, + }); + assert.deepEqual(Object.keys(completed.results).sort(), ["page", "worker"]); + for (const mode of ["page", "worker"]) + assert.deepEqual(completed.results[mode], baseline.results); + }, +}); +console.log( + `${platform}: ${Object.keys(eventCases).length} operation groups passed in page and Dedicated Worker (${hash})`, +); diff --git a/demo/tests/experiments/node-compat/export-types.json b/demo/tests/experiments/node-compat/export-types.json new file mode 100644 index 00000000..185a3440 --- /dev/null +++ b/demo/tests/experiments/node-compat/export-types.json @@ -0,0 +1,1746 @@ +{ + "profile": { + "compatibilityDate": "2026-10-17", + "workerd": "1.20261012.1" + }, + "sourceRevision": "5358e3d337336eaf696a48bc1563d808b10feba5", + "modules": { + "_http_agent": { + "Agent": "function", + "default": "object", + "globalAgent": "object" + }, + "_http_client": { + "ClientRequest": "function", + "default": "object" + }, + "_http_common": { + "CRLF": "string", + "_checkInvalidHeaderChar": "function", + "_checkIsHttpToken": "function", + "chunkExpression": "object", + "continueExpression": "object", + "default": "object", + "kIncomingMessage": "symbol", + "methods": "object", + "parsers": "object" + }, + "_http_incoming": { + "IncomingMessage": "function", + "default": "object" + }, + "_http_outgoing": { + "OutgoingMessage": "function", + "default": "object", + "kHighWaterMark": "symbol", + "kUniqueHeaders": "symbol", + "parseUniqueHeadersOption": "function", + "validateHeaderName": "function", + "validateHeaderValue": "function" + }, + "_http_server": { + "STATUS_CODES": "object", + "Server": "function", + "ServerResponse": "function", + "_connectionListener": "function", + "default": "object", + "httpServerPreClose": "function", + "kConnectionsCheckingInterval": "symbol", + "kServerResponse": "symbol", + "setupConnectionsTracking": "function", + "storeHTTPOptions": "function" + }, + "_stream_duplex": { + "Duplex": "function", + "default": "function", + "from": "function", + "fromWeb": "function", + "toWeb": "function" + }, + "_stream_passthrough": { + "PassThrough": "function", + "default": "function" + }, + "_stream_readable": { + "Readable": "function", + "ReadableState": "function", + "default": "function", + "from": "function", + "fromWeb": "function", + "toWeb": "function", + "wrap": "function" + }, + "_stream_transform": { + "Transform": "function", + "default": "function" + }, + "_stream_wrap": { + "default": "function" + }, + "_stream_writable": { + "Writable": "function", + "WritableState": "function", + "default": "function", + "fromWeb": "function", + "toWeb": "function" + }, + "_tls_common": { + "SecureContext": "function", + "createSecureContext": "function", + "default": "object", + "translatePeerCertificate": "function" + }, + "_tls_wrap": { + "TLSSocket": "function", + "connect": "function", + "default": "object" + }, + "assert": { + "AssertionError": "function", + "deepEqual": "function", + "deepStrictEqual": "function", + "default": "function", + "doesNotMatch": "function", + "doesNotReject": "function", + "doesNotThrow": "function", + "equal": "function", + "fail": "function", + "ifError": "function", + "match": "function", + "notDeepEqual": "function", + "notDeepStrictEqual": "function", + "notEqual": "function", + "notStrictEqual": "function", + "ok": "function", + "partialDeepStrictEqual": "function", + "rejects": "function", + "strict": "function", + "strictEqual": "function", + "throws": "function" + }, + "assert/strict": { + "AssertionError": "function", + "deepEqual": "function", + "deepStrictEqual": "function", + "default": "function", + "doesNotMatch": "function", + "doesNotReject": "function", + "doesNotThrow": "function", + "equal": "function", + "fail": "function", + "ifError": "function", + "match": "function", + "notDeepEqual": "function", + "notDeepStrictEqual": "function", + "notEqual": "function", + "notStrictEqual": "function", + "ok": "function", + "partialDeepStrictEqual": "function", + "rejects": "function", + "strict": "function", + "strictEqual": "function", + "throws": "function" + }, + "async_hooks": { + "AsyncLocalStorage": "function", + "AsyncResource": "function", + "asyncWrapProviders": "object", + "createHook": "function", + "default": "object", + "executionAsyncId": "function", + "executionAsyncResource": "function", + "triggerAsyncId": "function" + }, + "buffer": { + "Blob": "function", + "Buffer": "function", + "File": "function", + "INSPECT_MAX_BYTES": "number", + "SlowBuffer": "function", + "atob": "function", + "btoa": "function", + "constants": "object", + "default": "object", + "isAscii": "function", + "isUtf8": "function", + "kMaxLength": "number", + "kStringMaxLength": "number", + "resolveObjectURL": "function", + "transcode": "function" + }, + "child_process": { + "ChildProcess": "function", + "_forkChild": "function", + "default": "object", + "exec": "function", + "execFile": "function", + "execFileSync": "function", + "execSync": "function", + "fork": "function", + "spawn": "function", + "spawnSync": "function" + }, + "cluster": { + "Cluster": "function", + "SCHED_NONE": "number", + "SCHED_RR": "number", + "Worker": "function", + "_events": "object", + "_eventsCount": "number", + "_maxListeners": "number", + "default": "object", + "disconnect": "function", + "fork": "function", + "isMaster": "boolean", + "isPrimary": "boolean", + "isWorker": "boolean", + "schedulingPolicy": "number", + "settings": "object", + "setupMaster": "function", + "setupPrimary": "function", + "workers": "object" + }, + "console": { + "Console": "function", + "assert": "function", + "clear": "function", + "context": "function", + "count": "function", + "countReset": "function", + "createTask": "function", + "debug": "function", + "default": "object", + "dir": "function", + "dirxml": "function", + "error": "function", + "group": "function", + "groupCollapsed": "function", + "groupEnd": "function", + "info": "function", + "log": "function", + "profile": "function", + "profileEnd": "function", + "table": "function", + "time": "function", + "timeEnd": "function", + "timeLog": "function", + "timeStamp": "function", + "trace": "function", + "warn": "function" + }, + "constants": { + "COPYFILE_EXCL": "number", + "COPYFILE_FICLONE": "number", + "COPYFILE_FICLONE_FORCE": "number", + "DH_CHECK_P_NOT_PRIME": "number", + "DH_CHECK_P_NOT_SAFE_PRIME": "number", + "DH_NOT_SUITABLE_GENERATOR": "number", + "DH_UNABLE_TO_CHECK_GENERATOR": "number", + "E2BIG": "number", + "EACCES": "number", + "EADDRINUSE": "number", + "EADDRNOTAVAIL": "number", + "EAFNOSUPPORT": "number", + "EAGAIN": "number", + "EALREADY": "number", + "EBADF": "number", + "EBADMSG": "number", + "EBUSY": "number", + "ECANCELED": "number", + "ECHILD": "number", + "ECONNABORTED": "number", + "ECONNREFUSED": "number", + "ECONNRESET": "number", + "EDEADLK": "number", + "EDESTADDRREQ": "number", + "EDOM": "number", + "EDQUOT": "number", + "EEXIST": "number", + "EFAULT": "number", + "EFBIG": "number", + "EHOSTUNREACH": "number", + "EIDRM": "number", + "EILSEQ": "number", + "EINPROGRESS": "number", + "EINTR": "number", + "EINVAL": "number", + "EIO": "number", + "EISCONN": "number", + "EISDIR": "number", + "ELOOP": "number", + "EMFILE": "number", + "EMLINK": "number", + "EMSGSIZE": "number", + "EMULTIHOP": "number", + "ENAMETOOLONG": "number", + "ENETDOWN": "number", + "ENETRESET": "number", + "ENETUNREACH": "number", + "ENFILE": "number", + "ENGINE_METHOD_ALL": "number", + "ENGINE_METHOD_CIPHERS": "number", + "ENGINE_METHOD_DH": "number", + "ENGINE_METHOD_DIGESTS": "number", + "ENGINE_METHOD_DSA": "number", + "ENGINE_METHOD_EC": "number", + "ENGINE_METHOD_NONE": "number", + "ENGINE_METHOD_PKEY_ASN1_METHS": "number", + "ENGINE_METHOD_PKEY_METHS": "number", + "ENGINE_METHOD_RAND": "number", + "ENGINE_METHOD_RSA": "number", + "ENOBUFS": "number", + "ENODATA": "number", + "ENODEV": "number", + "ENOENT": "number", + "ENOEXEC": "number", + "ENOLCK": "number", + "ENOLINK": "number", + "ENOMEM": "number", + "ENOMSG": "number", + "ENOPROTOOPT": "number", + "ENOSPC": "number", + "ENOSR": "number", + "ENOSTR": "number", + "ENOSYS": "number", + "ENOTCONN": "number", + "ENOTDIR": "number", + "ENOTEMPTY": "number", + "ENOTSOCK": "number", + "ENOTSUP": "number", + "ENOTTY": "number", + "ENXIO": "number", + "EOPNOTSUPP": "number", + "EOVERFLOW": "number", + "EPERM": "number", + "EPIPE": "number", + "EPROTO": "number", + "EPROTONOSUPPORT": "number", + "EPROTOTYPE": "number", + "ERANGE": "number", + "EROFS": "number", + "ESPIPE": "number", + "ESRCH": "number", + "ESTALE": "number", + "ETIME": "number", + "ETIMEDOUT": "number", + "ETXTBSY": "number", + "EWOULDBLOCK": "number", + "EXDEV": "number", + "EXTENSIONLESS_FORMAT_JAVASCRIPT": "number", + "EXTENSIONLESS_FORMAT_WASM": "number", + "F_OK": "number", + "OPENSSL_VERSION_NUMBER": "number", + "O_APPEND": "number", + "O_CREAT": "number", + "O_DIRECT": "number", + "O_DIRECTORY": "number", + "O_DSYNC": "number", + "O_EXCL": "number", + "O_NOATIME": "number", + "O_NOCTTY": "number", + "O_NOFOLLOW": "number", + "O_NONBLOCK": "number", + "O_RDONLY": "number", + "O_RDWR": "number", + "O_SYMLINK": "number", + "O_SYNC": "number", + "O_TRUNC": "number", + "O_WRONLY": "number", + "POINT_CONVERSION_COMPRESSED": "number", + "POINT_CONVERSION_HYBRID": "number", + "POINT_CONVERSION_UNCOMPRESSED": "number", + "PRIORITY_ABOVE_NORMAL": "number", + "PRIORITY_BELOW_NORMAL": "number", + "PRIORITY_HIGH": "number", + "PRIORITY_HIGHEST": "number", + "PRIORITY_LOW": "number", + "PRIORITY_NORMAL": "number", + "RSA_NO_PADDING": "number", + "RSA_PKCS1_OAEP_PADDING": "number", + "RSA_PKCS1_PADDING": "number", + "RSA_PKCS1_PSS_PADDING": "number", + "RSA_PSS_SALTLEN_AUTO": "number", + "RSA_PSS_SALTLEN_DIGEST": "number", + "RSA_PSS_SALTLEN_MAX_SIGN": "number", + "RSA_X931_PADDING": "number", + "RTLD_DEEPBIND": "number", + "RTLD_GLOBAL": "number", + "RTLD_LAZY": "number", + "RTLD_LOCAL": "number", + "RTLD_NOW": "number", + "R_OK": "number", + "SIGABRT": "number", + "SIGALRM": "number", + "SIGBUS": "number", + "SIGCHLD": "number", + "SIGCONT": "number", + "SIGFPE": "number", + "SIGHUP": "number", + "SIGILL": "number", + "SIGINFO": "number", + "SIGINT": "number", + "SIGIO": "number", + "SIGIOT": "number", + "SIGKILL": "number", + "SIGPIPE": "number", + "SIGPOLL": "number", + "SIGPROF": "number", + "SIGPWR": "number", + "SIGQUIT": "number", + "SIGSEGV": "number", + "SIGSTKFLT": "number", + "SIGSTOP": "number", + "SIGSYS": "number", + "SIGTERM": "number", + "SIGTRAP": "number", + "SIGTSTP": "number", + "SIGTTIN": "number", + "SIGTTOU": "number", + "SIGURG": "number", + "SIGUSR1": "number", + "SIGUSR2": "number", + "SIGVTALRM": "number", + "SIGWINCH": "number", + "SIGXCPU": "number", + "SIGXFSZ": "number", + "SSL_OP_ALL": "number", + "SSL_OP_ALLOW_NO_DHE_KEX": "number", + "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION": "number", + "SSL_OP_CIPHER_SERVER_PREFERENCE": "number", + "SSL_OP_CISCO_ANYCONNECT": "number", + "SSL_OP_COOKIE_EXCHANGE": "number", + "SSL_OP_CRYPTOPRO_TLSEXT_BUG": "number", + "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS": "number", + "SSL_OP_LEGACY_SERVER_CONNECT": "number", + "SSL_OP_NO_COMPRESSION": "number", + "SSL_OP_NO_ENCRYPT_THEN_MAC": "number", + "SSL_OP_NO_QUERY_MTU": "number", + "SSL_OP_NO_RENEGOTIATION": "number", + "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION": "number", + "SSL_OP_NO_SSLv2": "number", + "SSL_OP_NO_SSLv3": "number", + "SSL_OP_NO_TICKET": "number", + "SSL_OP_NO_TLSv1": "number", + "SSL_OP_NO_TLSv1_1": "number", + "SSL_OP_NO_TLSv1_2": "number", + "SSL_OP_NO_TLSv1_3": "number", + "SSL_OP_PRIORITIZE_CHACHA": "number", + "SSL_OP_TLS_ROLLBACK_BUG": "number", + "S_IFBLK": "number", + "S_IFCHR": "number", + "S_IFDIR": "number", + "S_IFIFO": "number", + "S_IFLNK": "number", + "S_IFMT": "number", + "S_IFREG": "number", + "S_IFSOCK": "number", + "S_IRGRP": "number", + "S_IROTH": "number", + "S_IRUSR": "number", + "S_IRWXG": "number", + "S_IRWXO": "number", + "S_IRWXU": "number", + "S_IWGRP": "number", + "S_IWOTH": "number", + "S_IWUSR": "number", + "S_IXGRP": "number", + "S_IXOTH": "number", + "S_IXUSR": "number", + "TLS1_1_VERSION": "number", + "TLS1_2_VERSION": "number", + "TLS1_3_VERSION": "number", + "TLS1_VERSION": "number", + "UV_DIRENT_BLOCK": "number", + "UV_DIRENT_CHAR": "number", + "UV_DIRENT_DIR": "number", + "UV_DIRENT_FIFO": "number", + "UV_DIRENT_FILE": "number", + "UV_DIRENT_LINK": "number", + "UV_DIRENT_SOCKET": "number", + "UV_DIRENT_UNKNOWN": "number", + "UV_FS_COPYFILE_EXCL": "number", + "UV_FS_COPYFILE_FICLONE": "number", + "UV_FS_COPYFILE_FICLONE_FORCE": "number", + "UV_FS_O_FILEMAP": "number", + "UV_FS_SYMLINK_DIR": "number", + "UV_FS_SYMLINK_JUNCTION": "number", + "W_OK": "number", + "X_OK": "number", + "default": "object", + "defaultCipherList": "string", + "defaultCoreCipherList": "string" + }, + "crypto": { + "Certificate": "function", + "Cipher": "function", + "Cipheriv": "function", + "CryptoKey": "function", + "Decipher": "function", + "Decipheriv": "function", + "DiffieHellman": "function", + "DiffieHellmanGroup": "function", + "ECDH": "function", + "Hash": "function", + "Hmac": "function", + "KeyObject": "function", + "PrivateKeyObject": "function", + "PublicKeyObject": "function", + "SecretKeyObject": "function", + "Sign": "function", + "Verify": "function", + "X509Certificate": "function", + "checkPrime": "function", + "checkPrimeSync": "function", + "constants": "object", + "createCipher": "function", + "createCipheriv": "function", + "createDecipher": "function", + "createDecipheriv": "function", + "createDiffieHellman": "function", + "createDiffieHellmanGroup": "function", + "createECDH": "function", + "createHash": "function", + "createHmac": "function", + "createPrivateKey": "function", + "createPublicKey": "function", + "createSecretKey": "function", + "createSign": "function", + "createVerify": "function", + "default": "object", + "diffieHellman": "function", + "fips": "boolean", + "generateKey": "function", + "generateKeyPair": "function", + "generateKeyPairSync": "function", + "generateKeySync": "function", + "generatePrime": "function", + "generatePrimeSync": "function", + "getCipherInfo": "function", + "getCiphers": "function", + "getCurves": "function", + "getDiffieHellman": "function", + "getFips": "function", + "getHashes": "function", + "getRandomValues": "function", + "hash": "function", + "hkdf": "function", + "hkdfSync": "function", + "pbkdf2": "function", + "pbkdf2Sync": "function", + "privateDecrypt": "function", + "privateEncrypt": "function", + "pseudoRandomBytes": "function", + "publicDecrypt": "function", + "publicEncrypt": "function", + "randomBytes": "function", + "randomFill": "function", + "randomFillSync": "function", + "randomInt": "function", + "randomUUID": "function", + "scrypt": "function", + "scryptSync": "function", + "secureHeapUsed": "function", + "setEngine": "function", + "setFips": "function", + "sign": "function", + "subtle": "object", + "timingSafeEqual": "function", + "verify": "function", + "webcrypto": "object" + }, + "dgram": { + "Socket": "function", + "createSocket": "function", + "default": "object" + }, + "diagnostics_channel": { + "Channel": "function", + "TracingChannel": "function", + "channel": "function", + "default": "object", + "hasSubscribers": "function", + "subscribe": "function", + "tracingChannel": "function", + "unsubscribe": "function" + }, + "dns": { + "ADDRCONFIG": "number", + "ADDRGETNETWORKPARAMS": "string", + "ALL": "number", + "BADFAMILY": "string", + "BADFLAGS": "string", + "BADHINTS": "string", + "BADNAME": "string", + "BADQUERY": "string", + "BADRESP": "string", + "BADSTR": "string", + "CANCELLED": "string", + "CONNREFUSED": "string", + "DESTRUCTION": "string", + "EOF": "string", + "FILE": "string", + "FORMERR": "string", + "LOADIPHLPAPI": "string", + "NODATA": "string", + "NOMEM": "string", + "NONAME": "string", + "NOTFOUND": "string", + "NOTIMP": "string", + "NOTINITIALIZED": "string", + "REFUSED": "string", + "Resolver": "function", + "SERVFAIL": "string", + "TIMEOUT": "string", + "V4MAPPED": "number", + "default": "object", + "getDefaultResultOrder": "function", + "getServers": "function", + "lookup": "function", + "lookupService": "function", + "promises": "object", + "resolve": "function", + "resolve4": "function", + "resolve6": "function", + "resolveAny": "function", + "resolveCaa": "function", + "resolveCname": "function", + "resolveMx": "function", + "resolveNaptr": "function", + "resolveNs": "function", + "resolvePtr": "function", + "resolveSoa": "function", + "resolveSrv": "function", + "resolveTxt": "function", + "reverse": "function", + "setDefaultResultOrder": "function", + "setServers": "function" + }, + "dns/promises": { + "ADDRCONFIG": "number", + "ADDRGETNETWORKPARAMS": "string", + "ALL": "number", + "BADFAMILY": "string", + "BADFLAGS": "string", + "BADHINTS": "string", + "BADNAME": "string", + "BADQUERY": "string", + "BADRESP": "string", + "BADSTR": "string", + "CANCELLED": "string", + "CONNREFUSED": "string", + "DESTRUCTION": "string", + "EOF": "string", + "FILE": "string", + "FORMERR": "string", + "LOADIPHLPAPI": "string", + "NODATA": "string", + "NOMEM": "string", + "NONAME": "string", + "NOTFOUND": "string", + "NOTIMP": "string", + "NOTINITIALIZED": "string", + "REFUSED": "string", + "Resolver": "function", + "SERVFAIL": "string", + "TIMEOUT": "string", + "V4MAPPED": "number", + "default": "object", + "getDefaultResultOrder": "function", + "getServers": "function", + "lookup": "function", + "lookupService": "function", + "resolve": "function", + "resolve4": "function", + "resolve6": "function", + "resolveAny": "function", + "resolveCaa": "function", + "resolveCname": "function", + "resolveMx": "function", + "resolveNaptr": "function", + "resolveNs": "function", + "resolvePtr": "function", + "resolveSoa": "function", + "resolveSrv": "function", + "resolveTxt": "function", + "reverse": "function", + "setDefaultResultOrder": "function", + "setServers": "function" + }, + "domain": { + "Domain": "function", + "active": "object", + "create": "object", + "createDomain": "function", + "default": "object" + }, + "events": { + "EventEmitter": "function", + "EventEmitterAsyncResource": "function", + "addAbortListener": "function", + "captureRejectionSymbol": "symbol", + "captureRejections": "boolean", + "default": "function", + "defaultMaxListeners": "number", + "errorMonitor": "symbol", + "getEventListeners": "function", + "getMaxListeners": "function", + "listenerCount": "function", + "on": "function", + "once": "function", + "setMaxListeners": "function", + "usingDomains": "boolean" + }, + "fs": { + "Dir": "function", + "Dirent": "function", + "F_OK": "number", + "FileReadStream": "function", + "FileWriteStream": "function", + "R_OK": "number", + "ReadStream": "function", + "Stats": "function", + "W_OK": "number", + "WriteStream": "function", + "X_OK": "number", + "access": "function", + "accessSync": "function", + "appendFile": "function", + "appendFileSync": "function", + "chmod": "function", + "chmodSync": "function", + "chown": "function", + "chownSync": "function", + "close": "function", + "closeSync": "function", + "constants": "object", + "copyFile": "function", + "copyFileSync": "function", + "cp": "function", + "cpSync": "function", + "createReadStream": "function", + "createWriteStream": "function", + "default": "object", + "exists": "function", + "existsSync": "function", + "fchmod": "function", + "fchmodSync": "function", + "fchown": "function", + "fchownSync": "function", + "fdatasync": "function", + "fdatasyncSync": "function", + "fstat": "function", + "fstatSync": "function", + "fsync": "function", + "fsyncSync": "function", + "ftruncate": "function", + "ftruncateSync": "function", + "futimes": "function", + "futimesSync": "function", + "glob": "function", + "globSync": "function", + "lchmod": "function", + "lchmodSync": "function", + "lchown": "function", + "lchownSync": "function", + "link": "function", + "linkSync": "function", + "lstat": "function", + "lstatSync": "function", + "lutimes": "function", + "lutimesSync": "function", + "mkdir": "function", + "mkdirSync": "function", + "mkdtemp": "function", + "mkdtempSync": "function", + "open": "function", + "openAsBlob": "function", + "openSync": "function", + "opendir": "function", + "opendirSync": "function", + "promises": "object", + "read": "function", + "readFile": "function", + "readFileSync": "function", + "readSync": "function", + "readdir": "function", + "readdirSync": "function", + "readlink": "function", + "readlinkSync": "function", + "readv": "function", + "readvSync": "function", + "realpath": "function", + "realpathSync": "function", + "rename": "function", + "renameSync": "function", + "rm": "function", + "rmSync": "function", + "rmdir": "function", + "rmdirSync": "function", + "stat": "function", + "statSync": "function", + "statfs": "function", + "statfsSync": "function", + "symlink": "function", + "symlinkSync": "function", + "truncate": "function", + "truncateSync": "function", + "unlink": "function", + "unlinkSync": "function", + "unwatchFile": "function", + "utimes": "function", + "utimesSync": "function", + "watch": "function", + "watchFile": "function", + "write": "function", + "writeFile": "function", + "writeFileSync": "function", + "writeSync": "function", + "writev": "function", + "writevSync": "function" + }, + "fs/promises": { + "FileHandle": "function", + "access": "function", + "appendFile": "function", + "chmod": "function", + "chown": "function", + "constants": "object", + "copyFile": "function", + "cp": "function", + "default": "object", + "glob": "function", + "lchmod": "function", + "lchown": "function", + "link": "function", + "lstat": "function", + "lutimes": "function", + "mkdir": "function", + "mkdtemp": "function", + "open": "function", + "opendir": "function", + "readFile": "function", + "readdir": "function", + "readlink": "function", + "realpath": "function", + "rename": "function", + "rm": "function", + "rmdir": "function", + "stat": "function", + "statfs": "function", + "symlink": "function", + "truncate": "function", + "unlink": "function", + "utimes": "function", + "watch": "function", + "writeFile": "function" + }, + "http": { + "Agent": "function", + "ClientRequest": "function", + "CloseEvent": "function", + "IncomingMessage": "function", + "METHODS": "object", + "MessageEvent": "function", + "OutgoingMessage": "function", + "STATUS_CODES": "object", + "Server": "function", + "ServerResponse": "function", + "WebSocket": "function", + "_connectionListener": "function", + "createServer": "function", + "default": "object", + "get": "function", + "globalAgent": "object", + "maxHeaderSize": "number", + "request": "function", + "setMaxIdleHTTPParsers": "function", + "validateHeaderName": "function", + "validateHeaderValue": "function" + }, + "http2": { + "Http2ServerRequest": "function", + "Http2ServerResponse": "function", + "connect": "function", + "constants": "object", + "createSecureServer": "function", + "createServer": "function", + "default": "object", + "getDefaultSettings": "function", + "getPackedSettings": "function", + "getUnpackedSettings": "function", + "performServerHandshake": "function", + "sensitiveHeaders": "symbol" + }, + "https": { + "Agent": "function", + "Server": "function", + "createServer": "function", + "default": "object", + "get": "function", + "globalAgent": "object", + "request": "function" + }, + "inspector": { + "Network": "object", + "Session": "function", + "close": "function", + "console": "object", + "default": "object", + "open": "function", + "url": "function", + "waitForDebugger": "function" + }, + "inspector/promises": { + "Network": "object", + "Session": "function", + "close": "function", + "console": "object", + "default": "object", + "open": "function", + "url": "function", + "waitForDebugger": "function" + }, + "module": { + "Module": "function", + "SourceMap": "function", + "_cache": "object", + "_debug": "function", + "_extensions": "object", + "_findPath": "function", + "_initPaths": "function", + "_load": "function", + "_nodeModulePaths": "function", + "_pathCache": "object", + "_preloadModules": "function", + "_resolveFilename": "function", + "_resolveLookupPaths": "function", + "builtinModules": "object", + "constants": "object", + "createRequire": "function", + "default": "function", + "enableCompileCache": "function", + "findPackageJSON": "function", + "findSourceMap": "function", + "flushCompileCache": "function", + "getCompileCacheDir": "function", + "getSourceMapsSupport": "function", + "globalPaths": "object", + "isBuiltin": "function", + "register": "function", + "registerHooks": "function", + "runMain": "function", + "setSourceMapsSupport": "function", + "stripTypeScriptTypes": "function", + "syncBuiltinESMExports": "function", + "wrap": "function" + }, + "net": { + "BlockList": "function", + "BoundSocket": "function", + "Server": "function", + "Socket": "function", + "SocketAddress": "function", + "Stream": "function", + "_normalizeArgs": "function", + "connect": "function", + "createConnection": "function", + "createServer": "function", + "default": "object", + "getDefaultAutoSelectFamily": "function", + "getDefaultAutoSelectFamilyAttemptTimeout": "function", + "isIP": "function", + "isIPv4": "function", + "isIPv6": "function", + "setDefaultAutoSelectFamily": "function", + "setDefaultAutoSelectFamilyAttemptTimeout": "function" + }, + "os": { + "EOL": "string", + "arch": "function", + "availableParallelism": "function", + "constants": "object", + "cpus": "function", + "default": "object", + "devNull": "string", + "endianness": "function", + "freemem": "function", + "getPriority": "function", + "homedir": "function", + "hostname": "function", + "loadavg": "function", + "machine": "function", + "networkInterfaces": "function", + "platform": "function", + "release": "function", + "setPriority": "function", + "tmpdir": "function", + "totalmem": "function", + "type": "function", + "uptime": "function", + "userInfo": "function", + "version": "function" + }, + "path": { + "basename": "function", + "default": "object", + "delimiter": "string", + "dirname": "function", + "extname": "function", + "format": "function", + "isAbsolute": "function", + "join": "function", + "matchesGlob": "function", + "normalize": "function", + "parse": "function", + "posix": "object", + "relative": "function", + "resolve": "function", + "sep": "string", + "toNamespacedPath": "function", + "win32": "object" + }, + "path/posix": { + "basename": "function", + "default": "object", + "delimiter": "string", + "dirname": "function", + "extname": "function", + "format": "function", + "isAbsolute": "function", + "join": "function", + "matchesGlob": "function", + "normalize": "function", + "parse": "function", + "posix": "object", + "relative": "function", + "resolve": "function", + "sep": "string", + "toNamespacedPath": "function", + "win32": "object" + }, + "path/win32": { + "basename": "function", + "default": "object", + "delimiter": "string", + "dirname": "function", + "extname": "function", + "format": "function", + "isAbsolute": "function", + "join": "function", + "matchesGlob": "function", + "normalize": "function", + "parse": "function", + "posix": "object", + "relative": "function", + "resolve": "function", + "sep": "string", + "toNamespacedPath": "function", + "win32": "object" + }, + "perf_hooks": { + "Performance": "function", + "PerformanceEntry": "function", + "PerformanceMark": "function", + "PerformanceMeasure": "function", + "PerformanceObserver": "function", + "PerformanceObserverEntryList": "function", + "PerformanceResourceTiming": "function", + "constants": "object", + "createHistogram": "function", + "default": "object", + "eventLoopUtilization": "function", + "monitorEventLoopDelay": "function", + "performance": "object", + "timerify": "function" + }, + "process": { + "_channel": "undefined", + "_debugEnd": "function", + "_debugProcess": "function", + "_disconnect": "undefined", + "_events": "object", + "_eventsCount": "number", + "_exiting": "boolean", + "_fatalException": "function", + "_getActiveHandles": "function", + "_getActiveRequests": "function", + "_handleQueue": "undefined", + "_kill": "function", + "_linkedBinding": "function", + "_maxListeners": "undefined", + "_pendingMessage": "undefined", + "_preload_modules": "object", + "_rawDebug": "function", + "_send": "undefined", + "_startProfilerIdleNotifier": "function", + "_stopProfilerIdleNotifier": "function", + "_tickCallback": "function", + "abort": "function", + "allowedNodeEnvironmentFlags": "object", + "arch": "string", + "argv": "object", + "argv0": "string", + "assert": "function", + "availableMemory": "function", + "binding": "function", + "channel": "object", + "chdir": "function", + "config": "object", + "connected": "boolean", + "constrainedMemory": "function", + "cpuUsage": "function", + "cwd": "function", + "debugPort": "number", + "default": "object", + "dlopen": "function", + "domain": "object", + "emitWarning": "function", + "env": "object", + "execArgv": "object", + "execPath": "string", + "execve": "function", + "exit": "function", + "exitCode": "undefined", + "features": "object", + "finalization": "object", + "getActiveResourcesInfo": "function", + "getBuiltinModule": "function", + "getSourceMapsSupport": "function", + "getegid": "function", + "geteuid": "function", + "getgid": "function", + "getgroups": "function", + "getuid": "function", + "hasUncaughtExceptionCaptureCallback": "function", + "hrtime": "function", + "initgroups": "function", + "kill": "function", + "loadEnvFile": "function", + "memoryUsage": "function", + "moduleLoadList": "object", + "nextTick": "function", + "noDeprecation": "boolean", + "openStdin": "function", + "permission": "object", + "pid": "number", + "platform": "string", + "ppid": "number", + "reallyExit": "function", + "ref": "function", + "release": "object", + "report": "object", + "resourceUsage": "function", + "send": "function", + "setSourceMapsEnabled": "function", + "setUncaughtExceptionCaptureCallback": "function", + "setegid": "function", + "seteuid": "function", + "setgid": "function", + "setgroups": "function", + "setuid": "function", + "sourceMapsEnabled": "boolean", + "stderr": "object", + "stdin": "object", + "stdout": "object", + "threadCpuUsage": "function", + "throwDeprecation": "boolean", + "title": "string", + "traceDeprecation": "boolean", + "umask": "function", + "unref": "function", + "uptime": "function", + "version": "string", + "versions": "object" + }, + "punycode": { + "decode": "function", + "default": "object", + "encode": "function", + "toASCII": "function", + "toUnicode": "function", + "ucs2": "object", + "version": "string" + }, + "querystring": { + "decode": "function", + "default": "object", + "encode": "function", + "escape": "function", + "parse": "function", + "stringify": "function", + "unescape": "function", + "unescapeBuffer": "function" + }, + "readline": { + "Interface": "function", + "clearLine": "function", + "clearScreenDown": "function", + "createInterface": "function", + "cursorTo": "function", + "default": "object", + "emitKeypressEvents": "function", + "moveCursor": "function", + "promises": "object" + }, + "readline/promises": { + "Interface": "function", + "Readline": "function", + "createInterface": "function", + "default": "object" + }, + "repl": { + "REPLServer": "function", + "REPL_MODE_SLOPPY": "symbol", + "REPL_MODE_STRICT": "symbol", + "Recoverable": "function", + "_builtinLibs": "object", + "builtinModules": "object", + "default": "object", + "start": "function", + "writer": "function" + }, + "sqlite": { + "DatabaseSync": "function", + "StatementSync": "function", + "backup": "function", + "constants": "object", + "default": "object" + }, + "stream": { + "Duplex": "function", + "PassThrough": "function", + "Readable": "function", + "Stream": "function", + "Transform": "function", + "Writable": "function", + "_isArrayBufferView": "function", + "_isUint8Array": "function", + "_uint8ArrayToBuffer": "function", + "addAbortSignal": "function", + "compose": "function", + "default": "function", + "destroy": "function", + "duplexPair": "function", + "finished": "function", + "getDefaultHighWaterMark": "function", + "isDestroyed": "function", + "isDisturbed": "function", + "isErrored": "function", + "isReadable": "function", + "isWritable": "function", + "pipeline": "function", + "promises": "object", + "setDefaultHighWaterMark": "function" + }, + "stream/consumers": { + "arrayBuffer": "function", + "blob": "function", + "buffer": "function", + "default": "object", + "json": "function", + "text": "function" + }, + "stream/promises": { + "default": "object", + "finished": "function", + "pipeline": "function", + "promises": "object" + }, + "stream/web": { + "ByteLengthQueuingStrategy": "function", + "CompressionStream": "function", + "CountQueuingStrategy": "function", + "DecompressionStream": "function", + "ReadableByteStreamController": "function", + "ReadableStream": "function", + "ReadableStreamBYOBReader": "function", + "ReadableStreamBYOBRequest": "function", + "ReadableStreamDefaultController": "function", + "ReadableStreamDefaultReader": "function", + "TextDecoderStream": "function", + "TextEncoderStream": "function", + "TransformStream": "function", + "TransformStreamDefaultController": "function", + "WritableStream": "function", + "WritableStreamDefaultController": "function", + "WritableStreamDefaultWriter": "function", + "default": "object" + }, + "string_decoder": { + "StringDecoder": "function", + "default": "object" + }, + "sys": { + "MIMEParams": "function", + "MIMEType": "function", + "TextDecoder": "function", + "TextEncoder": "function", + "_errnoException": "function", + "_exceptionWithHostPort": "function", + "_extend": "function", + "aborted": "function", + "callbackify": "function", + "debug": "function", + "debuglog": "function", + "default": "object", + "deprecate": "function", + "format": "function", + "formatWithOptions": "function", + "getCallSite": "function", + "getCallSites": "function", + "getSystemErrorMap": "function", + "getSystemErrorMessage": "function", + "getSystemErrorName": "function", + "inherits": "function", + "inspect": "function", + "isArray": "function", + "isBoolean": "function", + "isBuffer": "function", + "isDate": "function", + "isDeepStrictEqual": "function", + "isError": "function", + "isFunction": "function", + "isNull": "function", + "isNullOrUndefined": "function", + "isNumber": "function", + "isObject": "function", + "isPrimitive": "function", + "isRegExp": "function", + "isString": "function", + "isSymbol": "function", + "isUndefined": "function", + "log": "function", + "parseArgs": "function", + "parseEnv": "function", + "promisify": "function", + "stripVTControlCharacters": "function", + "styleText": "function", + "toUSVString": "function", + "transferableAbortController": "function", + "transferableAbortSignal": "function", + "types": "object" + }, + "test": { + "MockFunctionContext": "function", + "MockTracker": "function", + "default": "object", + "mock": "object" + }, + "timers": { + "Timeout": "function", + "active": "function", + "clearImmediate": "function", + "clearInterval": "function", + "clearTimeout": "function", + "default": "object", + "enroll": "function", + "promises": "object", + "setImmediate": "function", + "setInterval": "function", + "setTimeout": "function", + "unenroll": "function" + }, + "timers/promises": { + "default": "object", + "scheduler": "object", + "setImmediate": "function", + "setInterval": "function", + "setTimeout": "function" + }, + "tls": { + "CLIENT_RENEG_LIMIT": "number", + "CLIENT_RENEG_WINDOW": "number", + "DEFAULT_CIPHERS": "string", + "DEFAULT_ECDH_CURVE": "string", + "DEFAULT_MAX_VERSION": "string", + "DEFAULT_MIN_VERSION": "string", + "SecureContext": "function", + "Server": "function", + "TLSSocket": "function", + "checkServerIdentity": "function", + "connect": "function", + "convertALPNProtocols": "function", + "createSecureContext": "function", + "createSecurePair": "function", + "createServer": "function", + "default": "object", + "getCiphers": "function", + "rootCertificates": "object" + }, + "trace_events": { + "createTracing": "function", + "default": "object", + "getEnabledCategories": "function" + }, + "tty": { + "ReadStream": "function", + "WriteStream": "function", + "default": "object", + "isatty": "function" + }, + "url": { + "URL": "function", + "URLSearchParams": "function", + "Url": "function", + "default": "object", + "domainToASCII": "function", + "domainToUnicode": "function", + "fileURLToPath": "function", + "format": "function", + "parse": "function", + "pathToFileURL": "function", + "resolve": "function", + "resolveObject": "function", + "toPathIfFileURL": "function", + "urlToHttpOptions": "function" + }, + "util": { + "MIMEParams": "function", + "MIMEType": "function", + "TextDecoder": "function", + "TextEncoder": "function", + "_errnoException": "function", + "_exceptionWithHostPort": "function", + "_extend": "function", + "aborted": "function", + "callbackify": "function", + "debug": "function", + "debuglog": "function", + "default": "object", + "deprecate": "function", + "format": "function", + "formatWithOptions": "function", + "getCallSite": "function", + "getCallSites": "function", + "getSystemErrorMap": "function", + "getSystemErrorMessage": "function", + "getSystemErrorName": "function", + "inherits": "function", + "inspect": "function", + "isArray": "function", + "isBoolean": "function", + "isBuffer": "function", + "isDate": "function", + "isDeepStrictEqual": "function", + "isError": "function", + "isFunction": "function", + "isNull": "function", + "isNullOrUndefined": "function", + "isNumber": "function", + "isObject": "function", + "isPrimitive": "function", + "isRegExp": "function", + "isString": "function", + "isSymbol": "function", + "isUndefined": "function", + "log": "function", + "parseArgs": "function", + "parseEnv": "function", + "promisify": "function", + "stripVTControlCharacters": "function", + "styleText": "function", + "toUSVString": "function", + "transferableAbortController": "function", + "transferableAbortSignal": "function", + "types": "object" + }, + "util/types": { + "default": "object", + "isAnyArrayBuffer": "function", + "isArgumentsObject": "function", + "isArrayBuffer": "function", + "isArrayBufferView": "function", + "isAsyncFunction": "function", + "isBigInt64Array": "function", + "isBigIntObject": "function", + "isBigUint64Array": "function", + "isBooleanObject": "function", + "isBoxedPrimitive": "function", + "isCryptoKey": "function", + "isDataView": "function", + "isDate": "function", + "isExternal": "function", + "isFloat16Array": "function", + "isFloat32Array": "function", + "isFloat64Array": "function", + "isGeneratorFunction": "function", + "isGeneratorObject": "function", + "isInt16Array": "function", + "isInt32Array": "function", + "isInt8Array": "function", + "isKeyObject": "function", + "isMap": "function", + "isMapIterator": "function", + "isModuleNamespaceObject": "function", + "isNativeError": "function", + "isNumberObject": "function", + "isPromise": "function", + "isProxy": "function", + "isRegExp": "function", + "isSet": "function", + "isSetIterator": "function", + "isSharedArrayBuffer": "function", + "isStringObject": "function", + "isSymbolObject": "function", + "isTypedArray": "function", + "isUint16Array": "function", + "isUint32Array": "function", + "isUint8Array": "function", + "isUint8ClampedArray": "function", + "isWeakMap": "function", + "isWeakSet": "function" + }, + "v8": { + "DefaultDeserializer": "function", + "DefaultSerializer": "function", + "Deserializer": "function", + "GCProfiler": "function", + "Serializer": "function", + "cachedDataVersionTag": "function", + "default": "object", + "deserialize": "function", + "getCppHeapStatistics": "function", + "getHeapCodeStatistics": "function", + "getHeapSnapshot": "function", + "getHeapSpaceStatistics": "function", + "getHeapStatistics": "function", + "isStringOneByteRepresentation": "function", + "promiseHooks": "object", + "queryObjects": "function", + "serialize": "function", + "setFlagsFromString": "function", + "setHeapSnapshotNearHeapLimit": "function", + "startupSnapshot": "object", + "stopCoverage": "function", + "takeCoverage": "function", + "writeHeapSnapshot": "function" + }, + "vm": { + "Script": "function", + "compileFunction": "function", + "constants": "object", + "createContext": "function", + "createScript": "function", + "default": "object", + "isContext": "function", + "measureMemory": "function", + "runInContext": "function", + "runInNewContext": "function", + "runInThisContext": "function" + }, + "wasi": { + "WASI": "function", + "default": "object" + }, + "worker_threads": { + "BroadcastChannel": "function", + "MessageChannel": "function", + "MessagePort": "function", + "SHARE_ENV": "symbol", + "Worker": "function", + "default": "object", + "getEnvironmentData": "function", + "isInternalThread": "boolean", + "isMainThread": "boolean", + "isMarkedAsUntransferable": "function", + "markAsUncloneable": "function", + "markAsUntransferable": "function", + "moveMessagePortToContext": "function", + "parentPort": "object", + "postMessageToThread": "function", + "receiveMessageOnPort": "function", + "resourceLimits": "object", + "setEnvironmentData": "function", + "threadId": "number", + "workerData": "object" + }, + "zlib": { + "BROTLI_DECODE": "number", + "BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES": "number", + "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP": "number", + "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES": "number", + "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1": "number", + "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2": "number", + "BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS": "number", + "BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET": "number", + "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1": "number", + "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2": "number", + "BROTLI_DECODER_ERROR_FORMAT_CL_SPACE": "number", + "BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT": "number", + "BROTLI_DECODER_ERROR_FORMAT_DICTIONARY": "number", + "BROTLI_DECODER_ERROR_FORMAT_DISTANCE": "number", + "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE": "number", + "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE": "number", + "BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE": "number", + "BROTLI_DECODER_ERROR_FORMAT_PADDING_1": "number", + "BROTLI_DECODER_ERROR_FORMAT_PADDING_2": "number", + "BROTLI_DECODER_ERROR_FORMAT_RESERVED": "number", + "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET": "number", + "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME": "number", + "BROTLI_DECODER_ERROR_FORMAT_TRANSFORM": "number", + "BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS": "number", + "BROTLI_DECODER_ERROR_INVALID_ARGUMENTS": "number", + "BROTLI_DECODER_ERROR_UNREACHABLE": "number", + "BROTLI_DECODER_NEEDS_MORE_INPUT": "number", + "BROTLI_DECODER_NEEDS_MORE_OUTPUT": "number", + "BROTLI_DECODER_NO_ERROR": "number", + "BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION": "number", + "BROTLI_DECODER_PARAM_LARGE_WINDOW": "number", + "BROTLI_DECODER_RESULT_ERROR": "number", + "BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT": "number", + "BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT": "number", + "BROTLI_DECODER_RESULT_SUCCESS": "number", + "BROTLI_DECODER_SUCCESS": "number", + "BROTLI_DEFAULT_MODE": "number", + "BROTLI_DEFAULT_QUALITY": "number", + "BROTLI_DEFAULT_WINDOW": "number", + "BROTLI_ENCODE": "number", + "BROTLI_LARGE_MAX_WINDOW_BITS": "number", + "BROTLI_MAX_INPUT_BLOCK_BITS": "number", + "BROTLI_MAX_QUALITY": "number", + "BROTLI_MAX_WINDOW_BITS": "number", + "BROTLI_MIN_INPUT_BLOCK_BITS": "number", + "BROTLI_MIN_QUALITY": "number", + "BROTLI_MIN_WINDOW_BITS": "number", + "BROTLI_MODE_FONT": "number", + "BROTLI_MODE_GENERIC": "number", + "BROTLI_MODE_TEXT": "number", + "BROTLI_OPERATION_EMIT_METADATA": "number", + "BROTLI_OPERATION_FINISH": "number", + "BROTLI_OPERATION_FLUSH": "number", + "BROTLI_OPERATION_PROCESS": "number", + "BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING": "number", + "BROTLI_PARAM_LARGE_WINDOW": "number", + "BROTLI_PARAM_LGBLOCK": "number", + "BROTLI_PARAM_LGWIN": "number", + "BROTLI_PARAM_MODE": "number", + "BROTLI_PARAM_NDIRECT": "number", + "BROTLI_PARAM_NPOSTFIX": "number", + "BROTLI_PARAM_QUALITY": "number", + "BrotliCompress": "function", + "BrotliDecompress": "function", + "DEFLATE": "number", + "DEFLATERAW": "number", + "Deflate": "function", + "DeflateRaw": "function", + "GUNZIP": "number", + "GZIP": "number", + "Gunzip": "function", + "Gzip": "function", + "INFLATE": "number", + "INFLATERAW": "number", + "Inflate": "function", + "InflateRaw": "function", + "UNZIP": "number", + "Unzip": "function", + "ZLIB_VERNUM": "number", + "ZSTD_COMPRESS": "number", + "ZSTD_DECODE": "number", + "ZSTD_DECOMPRESS": "number", + "ZSTD_ENCODE": "number", + "ZSTD_error_GENERIC": "number", + "ZSTD_error_checksum_wrong": "number", + "ZSTD_error_corruption_detected": "number", + "ZSTD_error_dictionaryCreation_failed": "number", + "ZSTD_error_dictionary_corrupted": "number", + "ZSTD_error_dictionary_wrong": "number", + "ZSTD_error_dstBuffer_null": "number", + "ZSTD_error_dstSize_tooSmall": "number", + "ZSTD_error_frameParameter_unsupported": "number", + "ZSTD_error_frameParameter_windowTooLarge": "number", + "ZSTD_error_init_missing": "number", + "ZSTD_error_literals_headerWrong": "number", + "ZSTD_error_maxSymbolValue_tooLarge": "number", + "ZSTD_error_maxSymbolValue_tooSmall": "number", + "ZSTD_error_memory_allocation": "number", + "ZSTD_error_noForwardProgress_destFull": "number", + "ZSTD_error_noForwardProgress_inputEmpty": "number", + "ZSTD_error_no_error": "number", + "ZSTD_error_parameter_combination_unsupported": "number", + "ZSTD_error_parameter_outOfBound": "number", + "ZSTD_error_parameter_unsupported": "number", + "ZSTD_error_prefix_unknown": "number", + "ZSTD_error_srcSize_wrong": "number", + "ZSTD_error_stabilityCondition_notRespected": "number", + "ZSTD_error_stage_wrong": "number", + "ZSTD_error_tableLog_tooLarge": "number", + "ZSTD_error_version_unsupported": "number", + "ZSTD_error_workSpace_tooSmall": "number", + "Z_BEST_COMPRESSION": "number", + "Z_BEST_SPEED": "number", + "Z_BLOCK": "number", + "Z_BUF_ERROR": "number", + "Z_DATA_ERROR": "number", + "Z_DEFAULT_CHUNK": "number", + "Z_DEFAULT_COMPRESSION": "number", + "Z_DEFAULT_LEVEL": "number", + "Z_DEFAULT_MEMLEVEL": "number", + "Z_DEFAULT_STRATEGY": "number", + "Z_DEFAULT_WINDOWBITS": "number", + "Z_ERRNO": "number", + "Z_FILTERED": "number", + "Z_FINISH": "number", + "Z_FIXED": "number", + "Z_FULL_FLUSH": "number", + "Z_HUFFMAN_ONLY": "number", + "Z_MAX_CHUNK": "number", + "Z_MAX_LEVEL": "number", + "Z_MAX_MEMLEVEL": "number", + "Z_MAX_WINDOWBITS": "number", + "Z_MEM_ERROR": "number", + "Z_MIN_CHUNK": "number", + "Z_MIN_LEVEL": "number", + "Z_MIN_MEMLEVEL": "number", + "Z_MIN_WINDOWBITS": "number", + "Z_NEED_DICT": "number", + "Z_NO_COMPRESSION": "number", + "Z_NO_FLUSH": "number", + "Z_OK": "number", + "Z_PARTIAL_FLUSH": "number", + "Z_RLE": "number", + "Z_STREAM_END": "number", + "Z_STREAM_ERROR": "number", + "Z_SYNC_FLUSH": "number", + "Z_VERSION_ERROR": "number", + "ZstdCompress": "function", + "ZstdDecompress": "function", + "brotliCompress": "function", + "brotliCompressSync": "function", + "brotliDecompress": "function", + "brotliDecompressSync": "function", + "codes": "object", + "constants": "object", + "crc32": "function", + "createBrotliCompress": "function", + "createBrotliDecompress": "function", + "createDeflate": "function", + "createDeflateRaw": "function", + "createGunzip": "function", + "createGzip": "function", + "createInflate": "function", + "createInflateRaw": "function", + "createUnzip": "function", + "createZstdCompress": "function", + "createZstdDecompress": "function", + "default": "object", + "deflate": "function", + "deflateRaw": "function", + "deflateRawSync": "function", + "deflateSync": "function", + "gunzip": "function", + "gunzipSync": "function", + "gzip": "function", + "gzipSync": "function", + "inflate": "function", + "inflateRaw": "function", + "inflateRawSync": "function", + "inflateSync": "function", + "unzip": "function", + "unzipSync": "function", + "zstdCompress": "function", + "zstdCompressSync": "function", + "zstdDecompress": "function", + "zstdDecompressSync": "function" + } + } +} diff --git a/demo/tests/experiments/node-compat/inventory.test.mjs b/demo/tests/experiments/node-compat/inventory.test.mjs index 382d8d1c..01915941 100644 --- a/demo/tests/experiments/node-compat/inventory.test.mjs +++ b/demo/tests/experiments/node-compat/inventory.test.mjs @@ -73,6 +73,25 @@ export default { async fetch() { ), expected.modules, ); + const expectedTypes = JSON.parse( + await readFile(new URL("export-types.json", import.meta.url), "utf8"), + ); + assert.deepEqual(expectedTypes.profile, profile); + assert.equal(expectedTypes.sourceRevision, expected.sourceRevision); + assert.deepEqual( + Object.fromEntries( + Object.entries(result.modules).map(([name, value]) => [ + name, + Object.fromEntries( + Object.entries(value.exports ?? {}).map(([key, descriptor]) => [ + key, + descriptor.type, + ]), + ), + ]), + ), + expectedTypes.modules, + ); await mkdir(artifacts, { recursive: true }); await writeFile( new URL("workerd.json", artifacts), diff --git a/demo/tests/experiments/node-compat/local-surface.test.mjs b/demo/tests/experiments/node-compat/local-surface.test.mjs index 47e69609..9cc72127 100644 --- a/demo/tests/experiments/node-compat/local-surface.test.mjs +++ b/demo/tests/experiments/node-compat/local-surface.test.mjs @@ -12,6 +12,14 @@ import { workersCapacitorPlugin } from "../../../../dist/tooling/esbuild.js"; const baseline = JSON.parse( await readFile(new URL("exports.json", import.meta.url), "utf8"), ); +const baselineTypes = JSON.parse( + await readFile(new URL("export-types.json", import.meta.url), "utf8"), +); +assert.deepEqual(baselineTypes.profile, baseline.profile); +assert.deepEqual( + Object.keys(baselineTypes.modules).sort(), + Object.keys(baseline.modules).sort(), +); const root = fileURLToPath(new URL("../../../..", import.meta.url)); const artifacts = new URL( "../../../artifacts/node-inventory/", @@ -65,9 +73,15 @@ for (const [engine, browserType] of Object.entries({ chromium, webkit })) { // Each module gets a fresh realm: import-time side effects cannot make // a later module appear supported or mask its initialization failure. const page = await browser.newPage(); + // Capacitor runs in a secure context; Web Crypto is unavailable on + // opaque about:blank origins in the browser harness. + await page.route("http://localhost/", (route) => + route.fulfill({ contentType: "text/html", body: "" }), + ); + await page.goto("http://localhost/"); try { modules[name] = await page.evaluate( - async ({ source, expected }) => { + async ({ source, expected, expectedTypes }) => { const url = URL.createObjectURL( new Blob([source], { type: "text/javascript" }), ); @@ -76,6 +90,17 @@ for (const [engine, browserType] of Object.entries({ chromium, webkit })) { const names = Object.keys(surface).sort(); return { surface, + typeMismatches: Object.fromEntries( + Object.entries(surface) + .filter( + ([key, value]) => + key in expectedTypes && value !== expectedTypes[key], + ) + .map(([key, actual]) => [ + key, + { expected: expectedTypes[key], actual }, + ]), + ), missing: expected.filter((name) => !names.includes(name)), extra: names.filter((name) => !expected.includes(name)), }; @@ -87,7 +112,11 @@ for (const [engine, browserType] of Object.entries({ chromium, webkit })) { URL.revokeObjectURL(url); } }, - { source: compiled.source, expected: baseline.modules[name] }, + { + source: compiled.source, + expected: baseline.modules[name], + expectedTypes: baselineTypes.modules[name], + }, ); } finally { await page.close(); @@ -110,7 +139,8 @@ for (const [engine, browserType] of Object.entries({ chromium, webkit })) { result.buildError || result.evaluationError || result.missing?.length || - result.extra?.length, + result.extra?.length || + Object.keys(result.typeMismatches ?? {}).length, ); for (const [name, result] of gaps) { assertNoSurfaceRegression( @@ -124,7 +154,7 @@ for (const [engine, browserType] of Object.entries({ chromium, webkit })) { ); for (const [name, result] of gaps) console.log( - `${name}: ${JSON.stringify(result.buildError ?? result.evaluationError ?? { missing: result.missing, extra: result.extra })}`, + `${name}: ${JSON.stringify(result.buildError ?? result.evaluationError ?? { missing: result.missing, extra: result.extra, typeMismatches: result.typeMismatches })}`, ); }); } diff --git a/demo/tests/experiments/node-compat/prepare-events-consumer.mjs b/demo/tests/experiments/node-compat/prepare-events-consumer.mjs new file mode 100644 index 00000000..4b686b42 --- /dev/null +++ b/demo/tests/experiments/node-compat/prepare-events-consumer.mjs @@ -0,0 +1,68 @@ +import { execFileSync } from "node:child_process"; +import { mkdir, mkdtemp, readFile, readdir, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { fileURLToPath } from "node:url"; +import { createHash } from "node:crypto"; +import assert from "node:assert/strict"; +const root = fileURLToPath(new URL("../../../..", import.meta.url)); +const output = new URL("../../../artifacts/node-inventory/", import.meta.url); +await mkdir(output, { recursive: true }); +await mkdir(join(root, "artifacts/npm"), { recursive: true }); +const packed = await mkdtemp(join(root, "artifacts/npm/events-")); +execFileSync("npm", ["pack", "--pack-destination", packed], { + cwd: root, + stdio: "inherit", +}); +const archives = (await readdir(packed)).filter((name) => + name.endsWith(".tgz"), +); +assert.equal(archives.length, 1); +const tarball = join(packed, archives[0]); +const tarballSha256 = createHash("sha256") + .update(await readFile(tarball)) + .digest("hex"); +// A real installed package prevents Xcode recursively traversing the checkout +// through a local npm link and also tests the distributable's runtime files. +const consumer = await mkdtemp(join(tmpdir(), "cf-events-consumer-")); +const dependencies = { "cf-workers-native": "file:" + tarball }; +for (const name of [ + "@capacitor/core", + "@capacitor/ios", + "@capacitor/android", + "@capacitor/cli", + "typescript", +]) { + dependencies[name] = JSON.parse( + await readFile( + join(root, "demo/node_modules", name, "package.json"), + "utf8", + ), + ).version; +} +await writeFile( + join(consumer, "package.json"), + JSON.stringify( + { name: "events-acceptance", private: true, type: "module", dependencies }, + null, + 2, + ) + "\n", +); +await writeFile( + join(consumer, "capacitor.config.ts"), + 'export default {appId:"jp.rdlabo.workerscapacitor.events",appName:"Events acceptance",webDir:"www"};\n', +); +await mkdir(join(consumer, "www")); +await writeFile( + join(consumer, "www/index.html"), + "Events acceptance", +); +execFileSync("npm", ["install", "--no-audit", "--no-fund"], { + cwd: consumer, + stdio: "inherit", +}); +await writeFile( + new URL("events-consumer.json", output), + JSON.stringify({ consumer, tarball, tarballSha256 }, null, 2) + "\n", +); +console.log(`Prepared independent events consumer: ${consumer}`); diff --git a/demo/tests/experiments/node-compat/surface-gaps.json b/demo/tests/experiments/node-compat/surface-gaps.json index ef479926..71b6d795 100644 --- a/demo/tests/experiments/node-compat/surface-gaps.json +++ b/demo/tests/experiments/node-compat/surface-gaps.json @@ -1,319 +1,39 @@ { "common": { - "_http_common": { - "buildError": ["Could not resolve \"node:_http_common\""] - }, - "_http_outgoing": { - "buildError": ["Could not resolve \"node:_http_outgoing\""] - }, - "_http_server": { - "buildError": ["Could not resolve \"node:_http_server\""] - }, - "_stream_wrap": { - "buildError": ["Could not resolve \"node:_stream_wrap\""] - }, - "_tls_wrap": { - "buildError": ["Could not resolve \"node:_tls_wrap\""] - }, "crypto": { "missing": [ "Certificate", - "CryptoKey", - "ECDH", - "KeyObject", - "PrivateKeyObject", - "PublicKeyObject", - "SecretKeyObject", "X509Certificate", - "checkPrime", - "checkPrimeSync", - "createPrivateKey", - "createPublicKey", - "createSecretKey", - "diffieHellman", "fips", - "generateKey", - "generateKeyPair", - "generateKeyPairSync", - "generateKeySync", - "generatePrime", - "generatePrimeSync", "getCipherInfo", - "getCurves", - "getFips", - "getRandomValues", - "hash", - "hkdf", - "hkdfSync", - "randomInt", - "randomUUID", - "scrypt", - "scryptSync", - "secureHeapUsed", - "setEngine", - "setFips", - "sign", - "subtle", - "timingSafeEqual", - "verify", - "webcrypto" + "getFips" ], "extra": ["createCredentials", "listCiphers", "prng", "rng"] }, - "events": { - "missing": [ - "EventEmitterAsyncResource", - "addAbortListener", - "captureRejectionSymbol", - "captureRejections", - "errorMonitor", - "getEventListeners", - "getMaxListeners", - "on", - "setMaxListeners", - "usingDomains" - ], - "extra": ["init"] - }, "fs": { - "missing": [ - "Dir", - "Dirent", - "F_OK", - "FileReadStream", - "FileWriteStream", - "R_OK", - "ReadStream", - "W_OK", - "WriteStream", - "X_OK", - "access", - "accessSync", - "appendFile", - "appendFileSync", - "chmod", - "chmodSync", - "chown", - "chownSync", - "close", - "closeSync", - "copyFile", - "copyFileSync", - "cp", - "cpSync", - "createReadStream", - "createWriteStream", - "exists", - "fchmod", - "fchmodSync", - "fchown", - "fchownSync", - "fdatasync", - "fdatasyncSync", - "fstat", - "fstatSync", - "fsync", - "fsyncSync", - "ftruncate", - "ftruncateSync", - "futimes", - "futimesSync", - "glob", - "globSync", - "lchmod", - "lchmodSync", - "lchown", - "lchownSync", - "link", - "linkSync", - "lstat", - "lutimes", - "lutimesSync", - "mkdir", - "mkdirSync", - "mkdtemp", - "mkdtempSync", - "open", - "openAsBlob", - "openSync", - "opendir", - "opendirSync", - "read", - "readSync", - "readlink", - "readlinkSync", - "readv", - "readvSync", - "realpath", - "rename", - "renameSync", - "rm", - "rmSync", - "rmdir", - "rmdirSync", - "statfs", - "statfsSync", - "symlink", - "symlinkSync", - "truncate", - "truncateSync", - "unlink", - "unlinkSync", - "unwatchFile", - "utimes", - "utimesSync", - "watch", - "watchFile", - "write", - "writeFile", - "writeFileSync", - "writeSync", - "writev", - "writevSync" - ], "extra": ["clearVirtualFiles", "registerVirtualFiles"] }, - "fs/promises": { - "missing": [ - "FileHandle", - "appendFile", - "chmod", - "chown", - "constants", - "copyFile", - "cp", - "glob", - "lchmod", - "lchown", - "link", - "lutimes", - "mkdir", - "mkdtemp", - "open", - "opendir", - "readlink", - "rename", - "rm", - "rmdir", - "statfs", - "symlink", - "truncate", - "unlink", - "utimes", - "watch", - "writeFile" - ], - "extra": [] - }, - "module": { - "missing": [ - "Module", - "SourceMap", - "_cache", - "_debug", - "_extensions", - "_findPath", - "_initPaths", - "_load", - "_nodeModulePaths", - "_pathCache", - "_preloadModules", - "_resolveFilename", - "_resolveLookupPaths", - "constants", - "enableCompileCache", - "findPackageJSON", - "findSourceMap", - "flushCompileCache", - "getCompileCacheDir", - "getSourceMapsSupport", - "globalPaths", - "register", - "registerHooks", - "runMain", - "setSourceMapsSupport", - "stripTypeScriptTypes", - "syncBuiltinESMExports", - "wrap" - ], - "extra": [] - }, "process": { "missing": [ "_channel", - "_debugEnd", - "_debugProcess", "_disconnect", "_events", "_eventsCount", - "_exiting", - "_fatalException", - "_getActiveHandles", - "_getActiveRequests", "_handleQueue", - "_kill", - "_linkedBinding", "_maxListeners", "_pendingMessage", - "_preload_modules", - "_rawDebug", "_send", - "_startProfilerIdleNotifier", - "_stopProfilerIdleNotifier", - "_tickCallback", "abort", - "allowedNodeEnvironmentFlags", "argv0", "assert", - "availableMemory", - "channel", "config", - "connected", - "constrainedMemory", - "cpuUsage", - "debugPort", - "domain", - "execve", - "exitCode", - "finalization", - "getActiveResourcesInfo", "getBuiltinModule", - "getSourceMapsSupport", - "getegid", - "geteuid", - "getgid", - "getgroups", - "getuid", - "hasUncaughtExceptionCaptureCallback", - "hrtime", - "initgroups", "loadEnvFile", - "moduleLoadList", - "noDeprecation", "openStdin", - "permission", - "ppid", "reallyExit", - "ref", - "release", - "report", - "resourceUsage", - "send", - "setSourceMapsEnabled", - "setUncaughtExceptionCaptureCallback", - "setegid", - "seteuid", - "setgid", - "setgroups", - "setuid", - "sourceMapsEnabled", "stderr", "stdin", - "stdout", - "threadCpuUsage", - "throwDeprecation", - "traceDeprecation", - "unref" + "stdout" ], "extra": [ "addListener", @@ -331,206 +51,15 @@ ] }, "sys": { - "missing": [ - "MIMEParams", - "MIMEType", - "TextDecoder", - "TextEncoder", - "_errnoException", - "_exceptionWithHostPort", - "aborted", - "debug", - "formatWithOptions", - "getCallSite", - "getCallSites", - "getSystemErrorMap", - "getSystemErrorMessage", - "getSystemErrorName", - "isDeepStrictEqual", - "parseArgs", - "parseEnv", - "stripVTControlCharacters", - "styleText", - "toUSVString", - "transferableAbortController", - "transferableAbortSignal" - ], - "extra": [] - }, - "tls": { - "missing": [ - "CLIENT_RENEG_LIMIT", - "CLIENT_RENEG_WINDOW", - "DEFAULT_CIPHERS", - "DEFAULT_ECDH_CURVE", - "DEFAULT_MAX_VERSION", - "DEFAULT_MIN_VERSION", - "SecureContext", - "Server", - "TLSSocket", - "checkServerIdentity", - "connect", - "convertALPNProtocols", - "createSecureContext", - "createSecurePair", - "createServer", - "getCiphers", - "rootCertificates" - ], - "extra": [] + "missing": ["getCallSite", "getCallSites"] }, "util": { - "missing": ["getCallSite", "getCallSites"], - "extra": [] - }, - "util/types": { - "buildError": ["Could not resolve \"node:util/types\""] + "missing": ["getCallSite", "getCallSites"] }, "zlib": { - "missing": [ - "BROTLI_DECODE", - "BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES", - "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP", - "BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES", - "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1", - "BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2", - "BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS", - "BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET", - "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1", - "BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2", - "BROTLI_DECODER_ERROR_FORMAT_CL_SPACE", - "BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT", - "BROTLI_DECODER_ERROR_FORMAT_DICTIONARY", - "BROTLI_DECODER_ERROR_FORMAT_DISTANCE", - "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE", - "BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE", - "BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE", - "BROTLI_DECODER_ERROR_FORMAT_PADDING_1", - "BROTLI_DECODER_ERROR_FORMAT_PADDING_2", - "BROTLI_DECODER_ERROR_FORMAT_RESERVED", - "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET", - "BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME", - "BROTLI_DECODER_ERROR_FORMAT_TRANSFORM", - "BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS", - "BROTLI_DECODER_ERROR_INVALID_ARGUMENTS", - "BROTLI_DECODER_ERROR_UNREACHABLE", - "BROTLI_DECODER_NEEDS_MORE_INPUT", - "BROTLI_DECODER_NEEDS_MORE_OUTPUT", - "BROTLI_DECODER_NO_ERROR", - "BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION", - "BROTLI_DECODER_PARAM_LARGE_WINDOW", - "BROTLI_DECODER_RESULT_ERROR", - "BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT", - "BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT", - "BROTLI_DECODER_RESULT_SUCCESS", - "BROTLI_DECODER_SUCCESS", - "BROTLI_DEFAULT_MODE", - "BROTLI_DEFAULT_QUALITY", - "BROTLI_DEFAULT_WINDOW", - "BROTLI_ENCODE", - "BROTLI_LARGE_MAX_WINDOW_BITS", - "BROTLI_MAX_INPUT_BLOCK_BITS", - "BROTLI_MAX_QUALITY", - "BROTLI_MAX_WINDOW_BITS", - "BROTLI_MIN_INPUT_BLOCK_BITS", - "BROTLI_MIN_QUALITY", - "BROTLI_MIN_WINDOW_BITS", - "BROTLI_MODE_FONT", - "BROTLI_MODE_GENERIC", - "BROTLI_MODE_TEXT", - "BROTLI_OPERATION_EMIT_METADATA", - "BROTLI_OPERATION_FINISH", - "BROTLI_OPERATION_FLUSH", - "BROTLI_OPERATION_PROCESS", - "BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING", - "BROTLI_PARAM_LARGE_WINDOW", - "BROTLI_PARAM_LGBLOCK", - "BROTLI_PARAM_LGWIN", - "BROTLI_PARAM_MODE", - "BROTLI_PARAM_NDIRECT", - "BROTLI_PARAM_NPOSTFIX", - "BROTLI_PARAM_QUALITY", - "BrotliCompress", - "BrotliDecompress", - "DEFLATE", - "DEFLATERAW", - "GUNZIP", - "GZIP", - "INFLATE", - "INFLATERAW", - "UNZIP", - "ZLIB_VERNUM", - "ZSTD_COMPRESS", - "ZSTD_DECODE", - "ZSTD_DECOMPRESS", - "ZSTD_ENCODE", - "ZSTD_error_GENERIC", - "ZSTD_error_checksum_wrong", - "ZSTD_error_corruption_detected", - "ZSTD_error_dictionaryCreation_failed", - "ZSTD_error_dictionary_corrupted", - "ZSTD_error_dictionary_wrong", - "ZSTD_error_dstBuffer_null", - "ZSTD_error_dstSize_tooSmall", - "ZSTD_error_frameParameter_unsupported", - "ZSTD_error_frameParameter_windowTooLarge", - "ZSTD_error_init_missing", - "ZSTD_error_literals_headerWrong", - "ZSTD_error_maxSymbolValue_tooLarge", - "ZSTD_error_maxSymbolValue_tooSmall", - "ZSTD_error_memory_allocation", - "ZSTD_error_noForwardProgress_destFull", - "ZSTD_error_noForwardProgress_inputEmpty", - "ZSTD_error_no_error", - "ZSTD_error_parameter_combination_unsupported", - "ZSTD_error_parameter_outOfBound", - "ZSTD_error_parameter_unsupported", - "ZSTD_error_prefix_unknown", - "ZSTD_error_srcSize_wrong", - "ZSTD_error_stabilityCondition_notRespected", - "ZSTD_error_stage_wrong", - "ZSTD_error_tableLog_tooLarge", - "ZSTD_error_version_unsupported", - "ZSTD_error_workSpace_tooSmall", - "Z_MEM_ERROR", - "Z_VERSION_ERROR", - "ZstdCompress", - "ZstdDecompress", - "brotliCompress", - "brotliCompressSync", - "brotliDecompress", - "brotliDecompressSync", - "constants", - "crc32", - "createBrotliCompress", - "createBrotliDecompress", - "createZstdCompress", - "createZstdDecompress", - "zstdCompress", - "zstdCompressSync", - "zstdDecompress", - "zstdDecompressSync" - ], - "extra": [ - "Z_BINARY", - "Z_DEFLATED", - "Z_TEXT", - "Z_TREES", - "Z_UNKNOWN", - "Zlib" - ] + "extra": ["Zlib"] } }, - "chromium": { - "console": { - "missing": ["Console"], - "extra": ["memory"] - } - }, - "webkit": { - "console": { - "missing": ["Console", "context", "createTask"], - "extra": ["record", "recordEnd", "screenshot", "takeHeapSnapshot"] - } - } + "chromium": {}, + "webkit": {} } diff --git a/demo/tests/experiments/node-compat/surface-regressions.mjs b/demo/tests/experiments/node-compat/surface-regressions.mjs index 8edc7ef1..2681d4ae 100644 --- a/demo/tests/experiments/node-compat/surface-regressions.mjs +++ b/demo/tests/experiments/node-compat/surface-regressions.mjs @@ -7,6 +7,11 @@ export function assertNoSurfaceRegression(name, actual, known = {}) { if (actual[stage]) assert.deepEqual(actual[stage], known[stage], `${name}: new ${stage}`); } + assert.deepEqual( + actual.typeMismatches ?? {}, + known.typeMismatches ?? {}, + `${name}: changed export types`, + ); // Previously unimportable modules may become importable incrementally. if (known.buildError || known.evaluationError) return; for (const kind of ["missing", "extra"]) { diff --git a/demo/tests/experiments/node-compat/surface-regressions.test.mjs b/demo/tests/experiments/node-compat/surface-regressions.test.mjs index 734a56f3..3c70e12f 100644 --- a/demo/tests/experiments/node-compat/surface-regressions.test.mjs +++ b/demo/tests/experiments/node-compat/surface-regressions.test.mjs @@ -24,3 +24,17 @@ test("import failure debt permits recovery but not a different failure", () => { check("module", { evaluationError: { name: "TypeError" } }, debt), ); }); + +test("an export retaining its name but losing callability is a regression", () => { + const broken = { + missing: [], + extra: [], + typeMismatches: { once: { expected: "function", actual: "object" } }, + }; + assert.throws(() => check("events", broken), /changed export types/); + assert.throws( + () => check("events", broken, { buildError: ["unresolved"] }), + /changed export types/, + ); + check("events", { missing: [], extra: [], typeMismatches: {} }); +}); diff --git a/docs/compatibility.md b/docs/compatibility.md index bbb910de..b274898a 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -27,21 +27,22 @@ and [verification scope](native-embedding.md#verification) for host-specific evi Whole-Node compatibility is incomplete. Importing a module successfully does not establish equivalent methods, validation, state, scheduling or engine behavior. -| Area | Behavior and limitations | -| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| path, querystring, string_decoder, buffer, timers | Implement the pinned Workers profile. Workers stubs remain stubs; for example, matchesGlob reproduces the pinned rejection. | -| HTTP and net | In-memory server dispatch; no OS listening server. Outbound TCP/TLS requires the native transport. | -| fs / fs/promises | Read-only embedded virtual files. Writes, FileHandle, watch and full filesystem semantics are unsupported. | -| module | Limited builtin registry; createRequire loads VFS JSON only. Executable modules must be bundled; arbitrary dynamic resolution is unsupported. | -| process, events, console, util / util/types / sys | Incomplete exports or behavior. Engine introspection, call sites and host-object detection are not equivalent to Workers. | -| crypto and zlib | Dependency implementations do not cover all Workers exports, algorithms, keys or codecs. Do not assume cryptographic or compression parity. | -| TLS and HTTP internals | node:tls is incomplete. \_http_common, \_http_outgoing, \_http_server, \_tls_wrap and \_stream_wrap fail the import audit. Native TLS transport does not imply Node TLS API compatibility. | -| Streams | A packaged fallback supplies byte streams when the host lacks them. Workers tee cancellation reasons and pipeTo abort timing are not fully reproduced. | -| async_hooks | Build-transformed async functions retain scoped stores. Untransformed native async callbacks reject; arbitrary dynamic code and request-origin isolation are not fully supported. | -| diagnostics_channel | Synchronous channel/store contracts are implemented; async propagation depends on the async-hooks limitations. | -| worker_threads | Workers stubs and local MessagePort behavior, not Node threads. Trusted-event branding, host-object serialization and global identity differ. | -| DNS | DNS-over-HTTPS implementation; synthetic Service Binding/Hyperdrive address overrides are not implemented. | -| Other modules | Implementations and shared contracts exist, but whole-module acceptance remains outstanding. Namespace equality alone is insufficient. | +| Area | Behavior and limitations | +| ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| path, querystring, string_decoder, buffer, timers | Implement the pinned Workers profile. Workers stubs remain stubs; for example, matchesGlob reproduces the pinned rejection. | +| HTTP and net | In-memory server dispatch; no OS listening server. Outbound TCP/TLS requires the native transport. | +| fs / fs/promises | Read-only embedded files plus request-local in-memory `/tmp`, with writes, descriptors and FileHandle operations. Watch is unsupported, as in Workers. Full filesystem semantics remain under audit. | +| module | Limited builtin registry; createRequire loads VFS JSON only. Executable modules must be bundled; arbitrary dynamic resolution is unsupported. | +| process, console, util / util/types / sys | Incomplete exports or behavior. Engine introspection, call sites and host-object detection are not equivalent to Workers. | +| crypto and zlib | Selected profiles cover random/hash/HKDF/scrypt, secret/asymmetric keys, signatures, primes and Brotli/Zstd streaming. X509/Certificate, additional algorithms and full crypto/codec parity remain gaps. | +| TLS and HTTP internals | TLS and HTTP internal imports resolve. Direct Node TLS exchange and hostname rejection are tested on native transports. Wrapping an existing socket is rejected before any TLS application write. Actual TLS upgrade and complete class/state contracts remain gaps. | +| Streams | An owned implementation supplies byte streams and the tested Workers tee cancellation and pipeTo abort behavior on every host. Whole-module acceptance remains open. | +| async_hooks | Build-transformed async functions retain scoped stores. Untransformed native async callbacks reject; arbitrary dynamic code and request-origin isolation are not fully supported. | +| diagnostics_channel | Synchronous channel/store contracts are implemented; async propagation depends on the async-hooks limitations. | +| worker_threads | Workers stubs and local MessagePort behavior, not Node threads. Trusted-event branding, host-object serialization and global identity differ. | +| DNS | DNS-over-HTTPS implementation; synthetic Service Binding/Hyperdrive address overrides are not implemented. | +| events | [WebView events profile](../src/compat/events/README.md): EventEmitter, abort/iteration helpers, transformed AsyncResource propagation and process warning delivery. Native async and V8 inspection remain bounded. | +| Other modules | Implementations and shared contracts exist, but whole-module acceptance remains outstanding. Namespace equality alone is insufficient. | The exact missing/extra export baseline is maintained in [surface-gaps.json](../demo/tests/experiments/node-compat/surface-gaps.json), against @@ -50,6 +51,57 @@ Those files are the source of truth; this guide does not duplicate the export li Run `npm run build`, then `npm run test:node-inventory --prefix demo` to check it. Behavioral contracts live beside each implementation in `src/compat`. +### Completion assessment + +The import audit checks export names and their JavaScript types against the pinned +Workers profile. A passing audit means no new surface regression; it does not +establish whole-module compatibility. In particular, a function replaced with an +object is now a regression even if the export name is unchanged. + +After `npm run build`, run `npm run test:node-completion --prefix demo` to regenerate +`demo/artifacts/node-inventory/completion.json`. The report covers every pinned +module in both Chromium and WebKit, distinguishes surface gaps from aligned but +uncertified modules, and records the next investigation with evidence references. +Missing engines, modules, type-audit data or a mismatched profile fail generation. +The optional report flag `--require-complete` rejects surface-only evidence; it +must not be used to turn report generation into a compatibility certificate. + +Residual work has different causes: + +- **Implementation gaps:** `crypto`, `zlib` and remaining virtual filesystem semantics + still need operation-level implementation and verification. Their absence is + not evidence of technical impossibility. +- **Behavior gaps:** Remaining stream lifecycle and synthetic DNS behavior require + specific adapters and contracts, beyond exporting the right names. +- **Engine boundaries:** proxy/promise introspection, native async continuation + hooks and trusted MessagePort branding have observable differences. Build-time + transforms or native bridges require explicit scope and separate verification. +- **Workers stubs:** preserve the pinned runtime's actual no-op/rejection behavior. + Do not implement desktop Node capabilities merely because Node exposes them. +- **Verification gaps:** even an aligned export surface needs whole-module + operation/prototype coverage and native acceptance before it is called complete. + +Run `npm run test:node-boundaries --prefix demo` for the counterexamples and +`npm run test:events --prefix demo` for the Workers events baseline and implementation. `node:events` is routed through the +[WebView events profile](../src/compat/events/README.md); process warning delivery +and microtask scheduling are shared with that adapter. Tests compare ordinary +Vite/esbuild imports in-page and in Dedicated Workers. Engine inspection and +untransformed native-async boundaries remain explicit; matching this profile does +not certify all Workers/Node modules. + +The [additional compatibility profiles](../src/compat/expansion/README.md) cover +console stubs, sys/util aliases, selected crypto operations, request-local `/tmp`, +secret KeyObjects, Brotli/Zstd/CRC32, filesystem metadata, stream cancellation, +module metadata and HTTP helpers. Run +`npm run test:node-expansion --prefix demo` for live differential tests against +the pinned Workers version. CI runs these checks alongside the existing events +suite. For native verification, prepare an installed consumer with +`npm run test:events:native:prepare --prefix demo`, then run +`npm run test:node-expansion:native --prefix demo -- ios ` or +`npm run test:node-expansion:native --prefix demo -- android `. +Native reports include the candidate hash and installed tarball identity under +`demo/artifacts/node-inventory/native-expansion/`. + Workers non-functional modules do not gain device capabilities: VM isolates, process spawning, V8 heap access, UDP sockets and an OS terminal are not supplied. `node:test` exposes the Workers mock API, not Node's complete test runner. diff --git a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java index 28df436f..69969443 100644 --- a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java +++ b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java @@ -85,7 +85,8 @@ void drain() { fail("Socket failed: "+error.getMessage()); } } - synchronized void open(String id,String host,int port,boolean tls,Result result) { + synchronized void open(String id,String host,int port,boolean tls,Result result) { open(id,host,port,tls,null,result); } + synchronized void open(String id,String host,int port,boolean tls,String servername,Result result) { if(stopped || id==null || id.isEmpty() || connections.containsKey(id) || host==null || host.isEmpty() || port<1 || port>65535) { result.reject("Invalid socket open"); return; } try { final SSLEngine engine; @@ -96,7 +97,7 @@ synchronized void open(String id,String host,int port,boolean tls,Result result) SSLContext context=SSLContext.getInstance("TLS"); context.init(null,null,null); tlsContext=context; } - engine=tlsContext.createSSLEngine(host,port); engine.setUseClientMode(true); + engine=tlsContext.createSSLEngine(servername==null || servername.isEmpty() ? host : servername,port); engine.setUseClientMode(true); SSLParameters parameters=engine.getSSLParameters(); parameters.setEndpointIdentificationAlgorithm("HTTPS"); engine.setSSLParameters(parameters); } else engine=null; if(group==null) group=new NioEventLoopGroup(1); diff --git a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java index a6ee7536..4b948e94 100644 --- a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java +++ b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java @@ -112,7 +112,7 @@ private WorkerSockets.Result result(PluginCall call) { @PluginMethod public void socketWatch(PluginCall call) { network.watch(call.getString("id"),result(call)); } @PluginMethod public void socketOpen(PluginCall call) { - network.open(call.getString("id"),call.getString("host"),call.getInt("port",0),call.getBoolean("tls",false),result(call)); + network.open(call.getString("id"),call.getString("host"),call.getInt("port",0),call.getBoolean("tls",false),call.getString("servername"),result(call)); } @PluginMethod public void socketWrite(PluginCall call) { network.write(call.getString("id"),call.getString("chunk"),result(call)); } @PluginMethod public void socketEnd(PluginCall call) { network.end(call.getString("id"),result(call)); } @@ -247,7 +247,7 @@ private class HostBridge { @JavascriptInterface public void cookiesGet(String callbackId,String url) { WorkersCapacitorPlugin.this.cookiesGet(url,hostResult(owner,callbackId)); } @JavascriptInterface public void cookiesSet(String callbackId,String url,String cookies) { WorkersCapacitorPlugin.this.cookiesSet(url,cookies,hostResult(owner,callbackId)); } @JavascriptInterface public void socketWatch(String callbackId,String id) { network.watch(id,hostResult(owner,callbackId)); } - @JavascriptInterface public void socketOpen(String callbackId,String id,String host,int port,boolean tls) { network.open(id,host,port,tls,hostResult(owner,callbackId)); } + @JavascriptInterface public void socketOpen(String callbackId,String id,String host,int port,boolean tls,String servername) { network.open(id,host,port,tls,servername,hostResult(owner,callbackId)); } @JavascriptInterface public void socketWrite(String callbackId,String id,String chunk) { network.write(id,chunk,hostResult(owner,callbackId)); } @JavascriptInterface public void socketEnd(String callbackId,String id) { network.end(id,hostResult(owner,callbackId)); } @JavascriptInterface public void socketRead(String callbackId,String id,int count) { network.read(id,count,hostResult(owner,callbackId)); } diff --git a/native/ios/NetworkBridge.swift b/native/ios/NetworkBridge.swift index 64cbc841..c4c565b3 100644 --- a/native/ios/NetworkBridge.swift +++ b/native/ios/NetworkBridge.swift @@ -28,7 +28,7 @@ final class NetworkBridge { } func socketOpen(_ call: CAPPluginCall) { guard let id = call.getString("id"), let host = call.getString("host"), let port = call.getInt("port") else { reject(call, "Invalid socket open"); return } - sockets.open(id: id, host: host, port: port, tls: call.getBool("tls") ?? false, completion: socketResult(call)) + sockets.open(id: id, host: host, port: port, tls: call.getBool("tls") ?? false, servername: call.getString("servername"), completion: socketResult(call)) } func socketWrite(_ call: CAPPluginCall) { guard let id = call.getString("id"), let encoded = call.getString("chunk"), encoded.utf8.count <= 87384, let data = Data(base64Encoded: encoded) else { reject(call, "Invalid socket write"); return } diff --git a/native/ios/SocketBridge.swift b/native/ios/SocketBridge.swift index 41d4035a..0cba3458 100644 --- a/native/ios/SocketBridge.swift +++ b/native/ios/SocketBridge.swift @@ -1,5 +1,6 @@ import Foundation import Network +import Security import Capacitor /// TCP byte transport. All state and completions belong to one serial queue. @@ -51,11 +52,17 @@ final class SocketBridge: @unchecked Sendable { let waiters = value.closeWaiters; value.closeWaiters.removeAll() for waiter in waiters { waiter() } } - func open(id: String, host: String, port: Int, tls: Bool, completion: @escaping Completion) { + func open(id: String, host: String, port: Int, tls: Bool, servername: String? = nil, completion: @escaping Completion) { queue.async { guard !self.stopped, !id.isEmpty, !host.isEmpty, port > 0, port <= 65535, self.values[id] == nil, let endpointPort = NWEndpoint.Port(rawValue: UInt16(port)) else { completion(.failure(Failure.invalid)); return } - let transport = NWConnection(host: NWEndpoint.Host(host), port: endpointPort, using: tls ? .tls : .tcp) + let parameters: NWParameters + if tls { + let options = NWProtocolTLS.Options() + sec_protocol_options_set_tls_server_name(options.securityProtocolOptions, servername ?? host) + parameters = NWParameters(tls: options, tcp: NWProtocolTCP.Options()) + } else { parameters = .tcp } + let transport = NWConnection(host: NWEndpoint.Host(host), port: endpointPort, using: parameters) let value = Connection(id, transport) value.opening = completion self.values[id] = value diff --git a/package.json b/package.json index b97d15e8..390ab8e1 100644 --- a/package.json +++ b/package.json @@ -111,12 +111,14 @@ "brotli-dec-wasm": "2.3.2", "esbuild": "^0.28.2", "jsonc-parser": "^3.3.1", + "memfs": "4.80.0", "node-stdlib-browser": "^1.3.1", "parse-srcset": "^1.0.2", "parse5": "^8.0.1", "punycode": "2.3.1", "readable-stream": "4.8.0", "rollup": "^4.64.9", + "scrypt-js": "3.0.1", "smol-toml": "^1.9.1", "string_decoder": "^1.3.0", "vite-plugin-node-polyfills": "^0.28.0", @@ -126,12 +128,12 @@ "@playwright/test": "^1.64.1", "@types/node": "^26.6.5", "hono": "^4.13.13", + "np": "^12.1.1", "prettier": "3.8.4", "typescript": "^7.0.2", "vite": "^7.3.7", "vitest": "^5.0.5", - "whatwg-url": "17.3.0", - "np": "^12.1.1" + "whatwg-url": "17.3.0" }, "peerDependencies": { "@capacitor/core": "^8.0.0", diff --git a/scripts/build-codecs.mjs b/scripts/build-codecs.mjs index 0636b6da..fa1a645f 100644 --- a/scripts/build-codecs.mjs +++ b/scripts/build-codecs.mjs @@ -1,4 +1,39 @@ import { build } from "esbuild"; +import { readFile } from "node:fs/promises"; +import { createHash } from "node:crypto"; + +// Fail before packaging if a generated implementation and its provenance drift. +for (const [asset, manifest] of [ + [ + "src/compat/crypto/native-crypto.wasm", + "src/compat/crypto/native-crypto.build.json", + ], + [ + "src/compat/zlib/native-codecs.wasm", + "src/compat/zlib/native-codecs.build.json", + ], + [ + "src/compat/stream-web/workers-ponyfill.js", + "src/compat/stream-web/workers-ponyfill.build.json", + ], +]) { + const provenance = JSON.parse(await readFile(manifest, "utf8")); + const expected = provenance.sha256; + if (provenance.bindingSha256) { + const binding = asset.replace(/\.wasm$/, ".c"); + if ( + createHash("sha256") + .update(await readFile(binding)) + .digest("hex") !== provenance.bindingSha256 + ) + throw new Error(`Native binding changed without rebuilding: ${binding}`); + } + const actual = createHash("sha256") + .update(await readFile(asset)) + .digest("hex"); + if (actual !== expected) + throw new Error(`Generated artifact hash mismatch: ${asset}`); +} // The package owns its codec asset. Consumers need no WASM loader or extra URL. await build({ entryPoints: ["src/shared/brotli/index.ts"], @@ -17,3 +52,21 @@ await build({ format: "esm", target: "es2022", }); + +await build({ + entryPoints: ["src/compat/zlib/native-codecs.ts"], + outfile: "dist/compat/zlib/native-codecs.js", + bundle: true, + format: "esm", + target: "es2022", + loader: { ".wasm": "binary" }, +}); + +await build({ + entryPoints: ["src/compat/crypto/native-crypto.ts"], + outfile: "dist/compat/crypto/native-crypto.js", + bundle: true, + format: "esm", + target: "es2022", + loader: { ".wasm": "binary" }, +}); diff --git a/scripts/build-native-codecs.mjs b/scripts/build-native-codecs.mjs new file mode 100644 index 00000000..a5909f54 --- /dev/null +++ b/scripts/build-native-codecs.mjs @@ -0,0 +1,76 @@ +import { execFileSync } from "node:child_process"; +import { readdirSync, readFileSync, writeFileSync } from "node:fs"; +import { join, resolve } from "node:path"; +import { createHash } from "node:crypto"; +// One-time/reproducibility build. Normal npm builds embed the checked-in Wasm +// and do not download a compiler or compile native sources. +const sdk = resolve(process.env.CODEC_EMSDK ?? "artifacts/toolchains/emsdk"); +const zstd = resolve("artifacts/upstream/zstd"); +const brotli = resolve("artifacts/upstream/brotli"); +const revision = (path) => + execFileSync("git", ["rev-parse", "HEAD"], { + cwd: path, + encoding: "utf8", + }).trim(); +const expected = { + emsdk: "e4fe26ef59168ff44f4c23c466e497bf60b3411e", + zstd: "f8745da6ff1ad1e7bab384bd1f9d742439278e99", + brotli: "ed738e842d2fbdf2d6459e39267a633c4a9b2f5d", +}; +const revisions = { + emsdk: revision(sdk), + zstd: revision(zstd), + brotli: revision(brotli), +}; +for (const name of Object.keys(expected)) + if (revisions[name] !== expected[name]) + throw new Error(`Unexpected ${name} revision: ${revisions[name]}`); +const sources = [ + ...["common", "compress", "decompress"].flatMap((dir) => + readdirSync(join(zstd, "lib", dir)) + .filter((n) => n.endsWith(".c")) + .sort() + .map((n) => join(zstd, "lib", dir, n)), + ), + ...["common", "enc", "dec"].flatMap((dir) => + readdirSync(join(brotli, "c", dir)) + .filter((n) => n.endsWith(".c")) + .sort() + .map((n) => join(brotli, "c", dir, n)), + ), +]; +const output = "src/compat/zlib/native-codecs.wasm"; +execFileSync( + join(sdk, "upstream/emscripten/emcc"), + [ + "src/compat/zlib/native-codecs.c", + ...sources, + "-I" + join(zstd, "lib"), + "-I" + join(brotli, "c/include"), + "-O3", + "-DNDEBUG", + "-DZSTD_DISABLE_ASM", + "-DBROTLI_BUILD_PORTABLE", + "-sSTANDALONE_WASM=1", + "-sALLOW_MEMORY_GROWTH=1", + "-sFILESYSTEM=0", + "-sASSERTIONS=0", + "-sMALLOC=emmalloc", + "--no-entry", + '-sEXPORTED_FUNCTIONS=["_malloc","_free"]', + "-o", + output, + ], + { stdio: "inherit" }, +); +writeFileSync( + "src/compat/zlib/native-codecs.build.json", + JSON.stringify( + { + revisions, + sha256: createHash("sha256").update(readFileSync(output)).digest("hex"), + }, + null, + 2, + ) + "\n", +); diff --git a/scripts/build-native-crypto.mjs b/scripts/build-native-crypto.mjs new file mode 100644 index 00000000..1268c01a --- /dev/null +++ b/scripts/build-native-crypto.mjs @@ -0,0 +1,95 @@ +import { execFileSync } from "node:child_process"; +import { readFileSync, writeFileSync } from "node:fs"; +import { resolve, join } from "node:path"; +import { createHash } from "node:crypto"; +import assert from "node:assert/strict"; +const sdk = resolve(process.env.CODEC_EMSDK ?? "artifacts/toolchains/emsdk"); +const source = resolve("artifacts/upstream/openssl"); +const revision = (directory) => + execFileSync("git", ["rev-parse", "HEAD"], { + cwd: directory, + encoding: "utf8", + }).trim(); +const revisions = { emsdk: revision(sdk), openssl: revision(source) }; +assert.equal(revisions.emsdk, "e4fe26ef59168ff44f4c23c466e497bf60b3411e"); +assert.equal(revisions.openssl, "45e844fa2a14ec92d146bd8f5778ac130b6625fb"); +assert.equal( + execFileSync("git", ["diff", "--name-only"], { + cwd: source, + encoding: "utf8", + }).trim(), + "", + "OpenSSL source must match the pinned revision", +); +const compiler = join(sdk, "upstream/emscripten"); +const configure = [ + "linux-generic32", + "--cross-compile-prefix=", + "no-asm", + "no-shared", + "no-threads", + "no-tests", + "no-dso", + "no-module", + "no-apps", + "no-docs", + "no-sock", + "no-ui-console", + "no-autoload-config", + "no-engine", + "no-afalgeng", + "--with-rand-seed=getrandom", + "-O3", +]; +if (!process.argv.includes("--link-only")) { + execFileSync(join(compiler, "emconfigure"), ["./Configure", ...configure], { + cwd: source, + stdio: "inherit", + }); + execFileSync(join(compiler, "emmake"), ["make", "-j4", "build_libs"], { + cwd: source, + stdio: "inherit", + }); +} +const binding = "src/compat/crypto/native-crypto.c"; +const output = "src/compat/crypto/native-crypto.wasm"; +const flags = [ + "-O3", + "-Wno-deprecated-declarations", + "-sSTANDALONE_WASM=1", + "-sALLOW_MEMORY_GROWTH=1", + "-sFILESYSTEM=0", + "-sASSERTIONS=0", + "-sMALLOC=emmalloc", + "-sABORTING_MALLOC=0", + "--no-entry", + '-sEXPORTED_FUNCTIONS=["_malloc","_free"]', +]; +execFileSync( + join(compiler, "emcc"), + [ + binding, + "-I" + join(source, "include"), + join(source, "libcrypto.a"), + ...flags, + "-o", + output, + ], + { stdio: "inherit" }, +); +const sha = (path) => + createHash("sha256").update(readFileSync(path)).digest("hex"); +writeFileSync( + "src/compat/crypto/native-crypto.build.json", + JSON.stringify( + { + revisions, + configure, + flags, + bindingSha256: sha(binding), + sha256: sha(output), + }, + null, + 2, + ) + "\n", +); diff --git a/scripts/build-workers-streams.mjs b/scripts/build-workers-streams.mjs new file mode 100644 index 00000000..80a27ddd --- /dev/null +++ b/scripts/build-workers-streams.mjs @@ -0,0 +1,107 @@ +import { build } from "esbuild"; +import { readFile, writeFile } from "node:fs/promises"; +import { execFileSync } from "node:child_process"; +import assert from "node:assert/strict"; +import { createHash } from "node:crypto"; +const root = "artifacts/upstream/web-streams-polyfill"; +const revision = execFileSync("git", ["rev-parse", "HEAD"], { + cwd: root, + encoding: "utf8", +}).trim(); +assert.equal(revision, "12b4fedec6c01503a137d837204ca0b85992461e"); +const changes = {}; +await build({ + entryPoints: [root + "/src/ponyfill.ts"], + outfile: "src/compat/stream-web/workers-ponyfill.js", + bundle: true, + format: "esm", + target: "es2022", + minify: true, + keepNames: true, + define: { DEBUG: "false" }, + banner: { + js: "// Generated from web-streams-polyfill 4.3.0 (MIT), with pinned Workers cancellation semantics.\n// Rebuild using scripts/build-workers-streams.mjs; see LICENSE.", + }, + plugins: [ + { + name: "workers-stream-behavior", + setup(build) { + build.onLoad( + { filter: /readable-stream\/(tee|pipe)\.ts$/ }, + async ({ path }) => { + let source = await readFile(path, "utf8"); + if (path.endsWith("/tee.ts")) { + const pattern = + "const compositeReason = CreateArrayFromList([reason1, reason2]);"; + assert.equal(source.split(pattern).length - 1, 4); + source = source.replaceAll( + pattern, + "const compositeReason = reason;", + ); + } else { + const replace = (from, to) => { + assert.equal(source.split(from).length - 1, 1, from); + source = source.replace(from, to); + }; + replace( + "actions.map(action => action())", + "actions.reverse().map(action => action())", + ); + replace( + "shutdownWithAction(() => Promise.all(actions.reverse().map(action => action())), true, error);", + "shutdownWithAction(() => Promise.all(actions.reverse().map(action => action())), true, error, true);", + ); + replace( + "const request = new PipeReadRequest(state);\n ReadableStreamDefaultReaderRead(reader, request);", + "const request = new PipeReadRequest(state);\n state._currentRead = request._promise;\n ReadableStreamDefaultReaderRead(reader, request);", + ); + replace( + "originalError?: any) {", + "originalError?: any, waitForRead = false) {", + ); + replace( + "if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\n uponFulfillment(state._waitForWritesToFinish(), doTheRest);\n } else {\n doTheRest();\n }", + "const read = waitForRead ? state._currentRead : undefined;\n uponFulfillment(read ? PerformPromiseThen(read, noop, noop) : promiseResolvedWith(undefined), () => {\n if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) uponFulfillment(state._waitForWritesToFinish(), doTheRest);\n else doTheRest();\n });", + ); + replace( + "class PipeState {\n _shuttingDown = false;", + "class PipeState {\n _shuttingDown = false;\n _currentRead: Promise | undefined;", + ); + // Two read request classes share this prefix; patch only PipeReadRequest. + assert.equal( + source.split( + "_chunkSteps(chunk: T) {\n this._state._currentWrite", + ).length - 1, + 2, + ); + source = source.replace( + "_chunkSteps(chunk: T) {\n this._state._currentWrite", + "_chunkSteps(chunk: T) {\n if (this._state._shuttingDown) {this._resolvePromise(false); return;}\n this._state._currentWrite", + ); + } + changes[path.endsWith("/tee.ts") ? "tee" : "pipe"] = createHash( + "sha256", + ) + .update(source) + .digest("hex"); + return { contents: source, loader: "ts" }; + }, + ); + }, + }, + ], +}); +await writeFile( + "src/compat/stream-web/workers-ponyfill.build.json", + JSON.stringify( + { + revision, + changes, + sha256: createHash("sha256") + .update(await readFile("src/compat/stream-web/workers-ponyfill.js")) + .digest("hex"), + }, + null, + 2, + ) + "\n", +); diff --git a/scripts/test-package.mjs b/scripts/test-package.mjs index 831f7369..9e49ade0 100644 --- a/scripts/test-package.mjs +++ b/scripts/test-package.mjs @@ -104,6 +104,22 @@ for (const module of [ throw new Error(`Missing upstream license notice in tarball: ${notice}`); } } +for (const notice of [ + "dist/compat/stream-web/LICENSE", + ...["openssl", "emscripten", "musl"].map( + (name) => `dist/compat/crypto/LICENSE.${name}`, + ), + "dist/compat/crypto/LICENSE-APACHE", + "dist/compat/crypto/LICENSE-3RD-PARTY.md", + ...["brotli", "zstd", "emscripten", "musl"].map( + (name) => `dist/compat/zlib/LICENSE.${name}`, + ), +]) { + assert.ok( + pack.files.some((file) => file.path === notice), + `Missing bundled implementation license: ${notice}`, + ); +} for (const name of ["NOTICE.md", "LICENSE-APACHE"]) { const notice = `dist/compat/async-hooks/${name}`; if (!pack.files.some((file) => file.path === notice)) diff --git a/src/browser/fetch/host-call.ts b/src/browser/fetch/host-call.ts index 5be7ddbd..4d3e5238 100644 --- a/src/browser/fetch/host-call.ts +++ b/src/browser/fetch/host-call.ts @@ -10,6 +10,7 @@ type Host = { host: string, port: number, tls: boolean, + servername: string, ): void; socketWrite(callback: string, id: string, chunk: string): void; socketEnd(callback: string, id: string): void; @@ -76,6 +77,9 @@ export function getHostCall(): NativeCall | undefined { String(args.host), Number(args.port), args.tls === true, + typeof args.servername === "string" + ? args.servername + : String(args.host), ); break; case "socketWrite": diff --git a/src/browser/isolated/transport.ts b/src/browser/isolated/transport.ts index 5139dcb2..326747b7 100644 --- a/src/browser/isolated/transport.ts +++ b/src/browser/isolated/transport.ts @@ -1,3 +1,4 @@ +import { runWithRequestScope } from "../../shared/request-scope.js"; import { setWorkerEnv } from "../../cloudflare/apis/cloudflare-workers/index.js"; import { isResponse } from "../fetch/interop.js"; import { Request as WorkerRequest } from "../request/index.js"; @@ -115,21 +116,23 @@ export function serve(worker: WorkerHandler) { body, signal: controller.signal, }); - const response = await worker.fetch(request as unknown as Request, env, { - props: {}, - passThroughOnException() { - throw new Error( - "passThroughOnException is unsupported for local execution.", - ); - }, - waitUntil(promise) { - pending.push( - promise.catch((cause) => { - errors.push(String(cause)); - }), - ); - }, - }); + const response = await runWithRequestScope(() => + worker.fetch(request as unknown as Request, env, { + props: {}, + passThroughOnException() { + throw new Error( + "passThroughOnException is unsupported for local execution.", + ); + }, + waitUntil(promise) { + pending.push( + promise.catch((cause) => { + errors.push(String(cause)); + }), + ); + }, + }), + ); if (!isResponse(response) || response.status === 0) throw new TypeError("worker.fetch must return a non-error Response."); if (response.bodyUsed || response.body?.locked) diff --git a/src/browser/request/index.ts b/src/browser/request/index.ts index 0f4c98a3..1063f1a2 100644 --- a/src/browser/request/index.ts +++ b/src/browser/request/index.ts @@ -1,4 +1,5 @@ -import { platform } from "../../shared/globals/platform.js"; +import { readable } from "../../compat/stream-web/interop.js"; +import { nativeStreams, platform } from "../../shared/globals/platform.js"; import { hasBody, inheritBodySource } from "../body/index.js"; import { Body, @@ -161,7 +162,12 @@ export class Request extends Body { "Request with a GET or HEAD method cannot have a body.", ); // Transfer only after all initializer validation succeeds. - if (nativeSource?.body) body = new platform.Request(nativeSource).body; + if (nativeSource?.body) + body = readable( + nativeSource.body.pipeThrough( + new nativeStreams.TransformStream(), + ), + ); else if (original && init.body === undefined) body = moveBody(original); super(body, headers); if (original && init.body === undefined) inheritBodySource(this, original); diff --git a/src/cloudflare/workers/worker-runtime.ts b/src/cloudflare/workers/worker-runtime.ts index af9136f3..bfe6cba1 100644 --- a/src/cloudflare/workers/worker-runtime.ts +++ b/src/cloudflare/workers/worker-runtime.ts @@ -1,3 +1,4 @@ +import { runWithRequestScope } from "../../shared/request-scope.js"; import { installWebGlobals } from "../../shared/globals/web.js"; import { createOutboundFetch } from "../../browser/fetch/outbound.js"; import { browserFetch, isRequest } from "../../browser/fetch/interop.js"; @@ -61,7 +62,7 @@ export class DirectFetchRuntime extends FetchRuntime { this.restoreWeb(); } protected dispatch(request: Request, env: Env, ctx: WorkerContext) { - return this.worker.fetch(request, env, ctx); + return runWithRequestScope(() => this.worker.fetch(request, env, ctx)); } } diff --git a/src/compat/console/index.ts b/src/compat/console/index.ts new file mode 100644 index 00000000..8e56ff00 --- /dev/null +++ b/src/compat/console/index.ts @@ -0,0 +1,112 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// Copyright Joyent and Node contributors. All rights reserved. MIT license. + +/* eslint-disable @typescript-eslint/no-unsafe-member-access */ + +class ERR_METHOD_NOT_IMPLEMENTED extends Error { + readonly code = "ERR_METHOD_NOT_IMPLEMENTED"; + constructor(method: string) { + super(`The ${method} method is not implemented`); + } +} +import processImpl from "node:process"; +import type { ConsoleOptions } from "node:console"; + +const noop: VoidFunction = () => {}; + +// TODO(soon): This class is Node.js compatible but globalThis.console is not. +// This is because globalThis.console is provided by the v8 runtime. +// We need to find a way to patch and add createTask and context methods whenever +// `enable_nodejs_console_module` flag is enabled. +const globalConsole = globalThis.console as typeof globalThis.console & { + _times: Map; + _ignoreErrors: boolean; + _stderrErrorHandler: () => void; + _stdoutErrorHandler: () => void; + _stderr: NodeJS.WritableStream; + _stdout: NodeJS.WritableStream; +}; + +globalConsole._times = new Map(); +globalConsole._ignoreErrors = true; +globalConsole._stderrErrorHandler = noop; +globalConsole._stdoutErrorHandler = noop; + +// We have this assertion because node-internal:public_process has undefined as the type +globalConsole._stderr = processImpl.stderr as unknown as NodeJS.WritableStream; +globalConsole._stdout = processImpl.stdout as unknown as NodeJS.WritableStream; + +export function Console(_options: ConsoleOptions): never { + throw new ERR_METHOD_NOT_IMPLEMENTED("Console"); +} +// We want to make sure the following works: +// ```js +// import mod from 'node:console`; +// new mod.Console(...) +// ``` +// @ts-expect-error TS2322 This is intentional. +globalConsole.Console = Console; + +export const log = console.log.bind(console); +Console.prototype.log = log; +export const info = console.info.bind(console); +Console.prototype.info = info; +export const debug = console.debug.bind(console); +Console.prototype.debug = debug; +export const warn = console.warn.bind(console); +Console.prototype.warn = warn; +export const error = console.error.bind(console); +Console.prototype.error = error; +export const dir = console.dir.bind(console); +Console.prototype.dir = dir; +export const time = console.time.bind(console); +Console.prototype.time = time; +export const timeEnd = console.timeEnd.bind(console); +Console.prototype.timeEnd = timeEnd; +export const timeLog = console.timeLog.bind(console); +Console.prototype.timeLog = timeLog; +export const trace = console.trace.bind(console); +Console.prototype.trace = trace; +export const assert = console.assert.bind(console); +Console.prototype.assert = assert; +export const clear = console.clear.bind(console); +Console.prototype.clear = clear; +export const count = console.count.bind(console); +Console.prototype.count = count; +export const countReset = console.countReset.bind(console); +Console.prototype.countReset = countReset; +export const group = console.group.bind(console); +Console.prototype.group = group; +export const groupEnd = console.groupEnd.bind(console); +Console.prototype.groupEnd = groupEnd; +export const table = console.table.bind(console); +Console.prototype.table = table; + +export const dirxml = console.dirxml.bind(console); +Console.prototype.dirxml = dirxml; +export const groupCollapsed = console.groupCollapsed.bind(console); +Console.prototype.groupCollapsed = groupCollapsed; +export const profile = console.profile.bind(console); +Console.prototype.profile = profile; +export const profileEnd = console.profileEnd.bind(console); +Console.prototype.profileEnd = profileEnd; +export const timeStamp = console.timeStamp.bind(console); +Console.prototype.timeStamp = timeStamp; + +export function context(): void { + throw new ERR_METHOD_NOT_IMPLEMENTED("Console.context"); +} +// @ts-expect-error TS2339 This is intentional. +globalConsole.context = context; +Console.prototype.context = context; + +export function createTask(): void { + throw new ERR_METHOD_NOT_IMPLEMENTED("Console.createTask"); +} +// @ts-expect-error TS2339 This is intentional. +globalConsole.createTask = createTask; +Console.prototype.createTask = createTask; + +export default globalConsole; diff --git a/src/compat/crypto/LICENSE-3RD-PARTY.md b/src/compat/crypto/LICENSE-3RD-PARTY.md new file mode 100644 index 00000000..88709535 --- /dev/null +++ b/src/compat/crypto/LICENSE-3RD-PARTY.md @@ -0,0 +1,15 @@ +# Upstream notices + +The net facade, internal implementation, logical port table, error classes and +validators are adapted from Cloudflare workerd tag `v1.20261012.1`: + +- `src/node/net.ts` +- `src/node/internal/internal_net.ts` +- `src/node/internal/internal_errors.ts` (required declarations only) +- `src/node/internal/validators.ts` (required declarations only) +- `src/cloudflare/internal/http.ts` + +Copyright Cloudflare, Inc.; Apache License 2.0. Node.js/Joyent and Deno MIT +notices are retained in the corresponding source files. Host transport and +module imports are adapted for Capacitor. Public exports remain those of the +pinned workerd module; internal helpers are not added to the public facade. diff --git a/src/compat/crypto/LICENSE-APACHE b/src/compat/crypto/LICENSE-APACHE new file mode 100644 index 00000000..f433b1a5 --- /dev/null +++ b/src/compat/crypto/LICENSE-APACHE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/src/compat/crypto/LICENSE.emscripten b/src/compat/crypto/LICENSE.emscripten new file mode 100644 index 00000000..70cabe38 --- /dev/null +++ b/src/compat/crypto/LICENSE.emscripten @@ -0,0 +1,102 @@ +Emscripten is available under 2 licenses, the MIT license and the +University of Illinois/NCSA Open Source License. + +Both are permissive open source licenses, with little if any +practical difference between them. + +The reason for offering both is that (1) the MIT license is +well-known, while (2) the University of Illinois/NCSA Open Source +License allows Emscripten's code to be integrated upstream into +LLVM, which uses that license, should the opportunity arise. + +The full text of both licenses follows. + +============================================================================== + +Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +============================================================================== + +Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal with the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + + Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimers. + + Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimers + in the documentation and/or other materials provided with the + distribution. + + Neither the names of Mozilla, + nor the names of its contributors may be used to endorse + or promote products derived from this Software without specific prior + written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE. + +============================================================================== + +This program uses portions of Node.js source code located in src/library_path.js, +in accordance with the terms of the MIT license. Node's license follows: + + """ + Copyright Joyent, Inc. and other Node contributors. All rights reserved. + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal in the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + IN THE SOFTWARE. + """ + +The musl libc project is bundled in this repo, and it has the MIT license, see +system/lib/libc/musl/COPYRIGHT + +The third_party/ subdirectory contains code with other licenses. None of it is +used by default, but certain options use it (e.g., the optional closure compiler +flag will run closure compiler from third_party/). + diff --git a/src/compat/crypto/LICENSE.musl b/src/compat/crypto/LICENSE.musl new file mode 100644 index 00000000..c1628e9a --- /dev/null +++ b/src/compat/crypto/LICENSE.musl @@ -0,0 +1,193 @@ +musl as a whole is licensed under the following standard MIT license: + +---------------------------------------------------------------------- +Copyright © 2005-2020 Rich Felker, et al. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +---------------------------------------------------------------------- + +Authors/contributors include: + +A. Wilcox +Ada Worcester +Alex Dowad +Alex Suykov +Alexander Monakov +Andre McCurdy +Andrew Kelley +Anthony G. Basile +Aric Belsito +Arvid Picciani +Bartosz Brachaczek +Benjamin Peterson +Bobby Bingham +Boris Brezillon +Brent Cook +Chris Spiegel +Clément Vasseur +Daniel Micay +Daniel Sabogal +Daurnimator +David Carlier +David Edelsohn +Denys Vlasenko +Dmitry Ivanov +Dmitry V. Levin +Drew DeVault +Emil Renner Berthing +Fangrui Song +Felix Fietkau +Felix Janda +Gianluca Anzolin +Hauke Mehrtens +He X +Hiltjo Posthuma +Isaac Dunham +Jaydeep Patil +Jens Gustedt +Jeremy Huntwork +Jo-Philipp Wich +Joakim Sindholt +John Spencer +Julien Ramseier +Justin Cormack +Kaarle Ritvanen +Khem Raj +Kylie McClain +Leah Neukirchen +Luca Barbato +Luka Perkov +M Farkas-Dyck (Strake) +Mahesh Bodapati +Markus Wichmann +Masanori Ogino +Michael Clark +Michael Forney +Mikhail Kremnyov +Natanael Copa +Nicholas J. Kain +orc +Pascal Cuoq +Patrick Oppenlander +Petr Hosek +Petr Skocik +Pierre Carrier +Reini Urban +Rich Felker +Richard Pennington +Ryan Fairfax +Samuel Holland +Segev Finer +Shiz +sin +Solar Designer +Stefan Kristiansson +Stefan O'Rear +Szabolcs Nagy +Timo Teräs +Trutz Behn +Valentin Ochs +Will Dietz +William Haddon +William Pitcock + +Portions of this software are derived from third-party works licensed +under terms compatible with the above MIT license: + +The TRE regular expression implementation (src/regex/reg* and +src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed +under a 2-clause BSD license (license text in the source files). The +included version has been heavily modified by Rich Felker in 2012, in +the interests of size, simplicity, and namespace cleanliness. + +Much of the math library code (src/math/* and src/complex/*) is +Copyright © 1993,2004 Sun Microsystems or +Copyright © 2003-2011 David Schultz or +Copyright © 2003-2009 Steven G. Kargl or +Copyright © 2003-2009 Bruce D. Evans or +Copyright © 2008 Stephen L. Moshier or +Copyright © 2017-2018 Arm Limited +and labelled as such in comments in the individual source files. All +have been licensed under extremely permissive terms. + +The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008 +The Android Open Source Project and is licensed under a two-clause BSD +license. It was taken from Bionic libc, used on Android. + +The AArch64 memcpy and memset code (src/string/aarch64/*) are +Copyright © 1999-2019, Arm Limited. + +The implementation of DES for crypt (src/crypt/crypt_des.c) is +Copyright © 1994 David Burren. It is licensed under a BSD license. + +The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was +originally written by Solar Designer and placed into the public +domain. The code also comes with a fallback permissive license for use +in jurisdictions that may not recognize the public domain. + +The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011 +Valentin Ochs and is licensed under an MIT-style license. + +The x86_64 port was written by Nicholas J. Kain and is licensed under +the standard MIT terms. + +The mips and microblaze ports were originally written by Richard +Pennington for use in the ellcc project. The original code was adapted +by Rich Felker for build system and code conventions during upstream +integration. It is licensed under the standard MIT terms. + +The mips64 port was contributed by Imagination Technologies and is +licensed under the standard MIT terms. + +The powerpc port was also originally written by Richard Pennington, +and later supplemented and integrated by John Spencer. It is licensed +under the standard MIT terms. + +All other files which have no copyright comments are original works +produced specifically for use as part of this library, written either +by Rich Felker, the main author of the library, or by one or more +contibutors listed above. Details on authorship of individual files +can be found in the git version control history of the project. The +omission of copyright and license comments in each file is in the +interest of source tree size. + +In addition, permission is hereby granted for all public header files +(include/* and arch/*/bits/*) and crt files intended to be linked into +applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit +the copyright notice and permission notice otherwise required by the +license, and to use these files without any requirement of +attribution. These files include substantial contributions from: + +Bobby Bingham +John Spencer +Nicholas J. Kain +Rich Felker +Richard Pennington +Stefan Kristiansson +Szabolcs Nagy + +all of whom have explicitly granted such permission. + +This file previously contained text expressing a belief that most of +the files covered by the above exception were sufficiently trivial not +to be subject to copyright, resulting in confusion over whether it +negated the permissions granted in the license. In the spirit of +permissive licensing, and of not having licensing issues being an +obstacle to adoption, that text has been removed. diff --git a/src/compat/crypto/LICENSE.openssl b/src/compat/crypto/LICENSE.openssl new file mode 100644 index 00000000..49cc83d2 --- /dev/null +++ b/src/compat/crypto/LICENSE.openssl @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + https://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/src/compat/crypto/asymmetric.ts b/src/compat/crypto/asymmetric.ts new file mode 100644 index 00000000..bcb99fb3 --- /dev/null +++ b/src/compat/crypto/asymmetric.ts @@ -0,0 +1,332 @@ +import { Buffer } from "node:buffer"; +import { NativeKey, nativeTimingEqual } from "./native-crypto.js"; +import { importJwk } from "./key-formats.js"; +import { + create, + KeyObject, + PrivateKeyObject, + PublicKeyObject, +} from "./keys.js"; +import { keyStates } from "./key-state.js"; +import { bytes, validateInteger } from "./validation.js"; +import { + validateObject, + validateString, + validateOneOf, + validateFunction, + validateUint32, +} from "../net/validators.js"; +import { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE } from "../net/errors.js"; +function handle(key: KeyObject): NativeKey { + const value = keyStates.get(key)?.asymmetric; + if (!value) + throw Object.assign( + new Error( + "Synchronous access to opaque host key material is unavailable", + ), + { code: "ERR_METHOD_NOT_IMPLEMENTED" }, + ); + return value; +} +function input(value: any, privateKey: boolean): NativeKey { + if (value == null) + throw new ERR_INVALID_ARG_TYPE( + "key", + ["ArrayBuffer", "Buffer", "TypedArray", "DataView", "string", "object"], + value, + ); + const options = + typeof value === "string" || + value instanceof ArrayBuffer || + ArrayBuffer.isView(value) + ? { key: value } + : value; + const data = options.key; + if ( + data == null || + data instanceof KeyObject || + data instanceof globalThis.CryptoKey + ) + throw new ERR_INVALID_ARG_TYPE( + "options.key", + ["ArrayBuffer", "Buffer", "TypedArray", "DataView", "string", "object"], + data, + ); + if ( + typeof data === "object" && + !(data instanceof ArrayBuffer) && + !ArrayBuffer.isView(data) + ) + return importJwk(data, privateKey); + const format = options.format ?? "pem"; + validateOneOf(format, "format", ["pem", "der"]); + if (options.type !== undefined) + validateOneOf( + options.type, + "type", + privateKey ? ["pkcs1", "pkcs8", "sec1"] : ["pkcs1", "spki"], + ); + const raw = + typeof data === "string" + ? Buffer.from(data, options.encoding ?? "utf8") + : bytes(data, "key"); + const password = + options.passphrase === undefined + ? undefined + : typeof options.passphrase === "string" + ? Buffer.from(options.passphrase, options.encoding ?? "utf8") + : bytes(options.passphrase, "passphrase"); + if (privateKey) return NativeKey.parse(raw, format === "pem", true, password); + try { + return NativeKey.parse(raw, format === "pem", false, password); + } catch (error) { + // createPublicKey also accepts a serialized private key, deriving public material. + let key: NativeKey; + try { + key = NativeKey.parse(raw, format === "pem", true, password); + } catch { + throw error; + } + try { + return NativeKey.parse(key.export(false, false, "spki"), false, false); + } finally { + key.dispose(); + } + } +} +export function createPrivateKey(value: unknown): PrivateKeyObject { + return create("private", { + asymmetric: input(value, true), + }) as PrivateKeyObject; +} +export function createPublicKey(value: any): PublicKeyObject { + if (keyStates.has(value)) { + if (value.type !== "private") + throw new ERR_INVALID_ARG_TYPE("key", "PrivateKeyObject", value); + return create("public", { + asymmetric: NativeKey.parse( + handle(value).export(false, false, "spki"), + false, + false, + ), + }) as PublicKeyObject; + } + return create("public", { + asymmetric: input(value, false), + }) as PublicKeyObject; +} +export function generateKeyPairSync(type: string, options: any = {}) { + validateOneOf(type, "type", ["rsa", "ec", "ed25519", "x25519", "dh"]); + validateObject(options, "options"); + let key: NativeKey; + if (type === "rsa") { + validateUint32(options.modulusLength, "options.modulusLength"); + validateUint32(options.publicExponent ?? 65537, "options.publicExponent"); + key = NativeKey.generate( + "RSA", + options.modulusLength, + undefined, + options.publicExponent ?? 65537, + ); + } else if (type === "ec") { + validateString(options.namedCurve, "options.namedCurve"); + validateOneOf(options.paramEncoding ?? "named", "options.paramEncoding", [ + "named", + "explicit", + ]); + key = NativeKey.generate("EC", 0, options.namedCurve); + } else if (type === "dh") { + const groups: Record = { + modp1: "modp_768", + modp2: "modp_1024", + modp5: "modp_1536", + modp14: "modp_2048", + modp15: "modp_3072", + modp16: "modp_4096", + modp17: "modp_6144", + modp18: "modp_8192", + }; + const group = options.group ?? options.groupName; + validateString(group, "options.group"); + key = NativeKey.generate("DH", 0, groups[group] ?? group); + } else key = NativeKey.generate(type.toUpperCase()); + const privateKey = create("private", { asymmetric: key }) as PrivateKeyObject; + const publicKey = createPublicKey(privateKey); + return { + publicKey: options.publicKeyEncoding + ? publicKey.export(options.publicKeyEncoding) + : publicKey, + privateKey: options.privateKeyEncoding + ? privateKey.export(options.privateKeyEncoding) + : privateKey, + }; +} +export function generateKeyPair( + type: string, + options: any, + callback: any, +): void { + if (typeof options === "function") { + callback = options; + options = {}; + } + validateFunction(callback, "callback"); + let result: ReturnType | undefined, + failure: unknown; + try { + result = generateKeyPairSync(type, options); + } catch (error) { + failure = error; + } + queueMicrotask(() => + failure + ? callback(failure) + : callback(null, result!.publicKey, result!.privateKey), + ); +} +function optionsOf(value: any) { + return value && + typeof value === "object" && + !keyStates.has(value) && + "key" in value + ? value + : { key: value }; +} +function operationKey(value: any, privateKey: boolean): KeyObject { + const key = optionsOf(value).key; + if (keyStates.has(key)) { + if (key.type === "secret" || (privateKey && key.type !== "private")) + throw new TypeError("Invalid key type"); + return key; + } + return privateKey ? createPrivateKey(value) : createPublicKey(value); +} +function digestName(algorithm: any): string | null { + if (algorithm == null) return null; + validateString(algorithm, "algorithm"); + return algorithm; +} +export function sign( + algorithm: any, + data: unknown, + key: any, + callback?: any, +): any { + if (callback !== undefined) validateFunction(callback, "callback"); + const digest = digestName(algorithm), + raw = bytes(data, "data"); + const execute = () => { + const options = optionsOf(key); + return Buffer.from( + handle(operationKey(key, true)).sign( + digest, + raw, + options.padding ?? 0, + options.saltLength ?? -1, + options.dsaEncoding === "ieee-p1363", + ), + ); + }; + if (callback === undefined) return execute(); + let result: Buffer | undefined, failure: unknown; + try { + result = execute(); + } catch (error) { + failure = error; + } + queueMicrotask(() => callback(failure ?? null, result)); +} +export function verify( + algorithm: any, + data: unknown, + key: any, + signature: unknown, + callback?: any, +): any { + if (callback !== undefined) validateFunction(callback, "callback"); + const digest = digestName(algorithm), + raw = bytes(data, "data"), + sig = bytes(signature, "signature"); + const execute = () => { + const options = optionsOf(key); + return handle(operationKey(key, false)).verify( + digest, + raw, + sig, + options.padding ?? 0, + options.saltLength ?? -1, + options.dsaEncoding === "ieee-p1363", + ); + }; + if (callback === undefined) return execute(); + let result: boolean | undefined, failure: unknown; + try { + result = execute(); + } catch (error) { + failure = error; + } + queueMicrotask(() => callback(failure ?? null, result)); +} +export function diffieHellman(options: any): Buffer { + validateObject(options, "options"); + const { publicKey, privateKey } = options; + if (!keyStates.has(publicKey)) + throw new ERR_INVALID_ARG_TYPE("options.publicKey", "KeyObject", publicKey); + if (!keyStates.has(privateKey)) + throw new ERR_INVALID_ARG_TYPE( + "options.privateKey", + "KeyObject", + privateKey, + ); + if (publicKey.type !== "public") + throw new ERR_INVALID_ARG_TYPE( + "options.publicKey", + "public key", + publicKey, + ); + if (privateKey.type !== "private") + throw new ERR_INVALID_ARG_TYPE( + "options.privateKey", + "private key", + privateKey, + ); + if (publicKey.asymmetricKeyType !== privateKey.asymmetricKeyType) + throw new ERR_INVALID_ARG_VALUE( + "options.publicKey.asymmetricKeyType", + publicKey.asymmetricKeyType, + "must equal privateKey.asymmetricKeyType", + ); + const publicHandle = handle(publicKey), + privateHandle = handle(privateKey); + + // The pinned workerd crypto-keys.c++ passes the public key as the first + // DHPointer::stateless argument. Preserve its observable failure rather than + // silently substituting standalone Node behavior. + try { + return Buffer.from(publicHandle.derive(privateHandle)); + } catch { + throw new Error("Failed to derive shared diffie-hellman secret"); + } +} +export function timingSafeEqual(a: unknown, b: unknown): boolean { + if (!(a instanceof ArrayBuffer) && !ArrayBuffer.isView(a)) + throw new ERR_INVALID_ARG_TYPE( + "buf1", + ["ArrayBuffer", "Buffer", "TypedArray", "DataView"], + a, + ); + if (!(b instanceof ArrayBuffer) && !ArrayBuffer.isView(b)) + throw new ERR_INVALID_ARG_TYPE( + "buf2", + ["ArrayBuffer", "Buffer", "TypedArray", "DataView"], + b, + ); + const left = bytes(a, "buf1"), + right = bytes(b, "buf2"); + if (left.length !== right.length) + throw Object.assign( + new RangeError("Input buffers must have the same byte length"), + { code: "ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH" }, + ); + return nativeTimingEqual(left, right); +} diff --git a/src/compat/crypto/brorand.cjs b/src/compat/crypto/brorand.cjs new file mode 100644 index 00000000..e407ebe7 --- /dev/null +++ b/src/compat/crypto/brorand.cjs @@ -0,0 +1,76 @@ +/* Browser-only adaptation of brorand 1.1.0. + +This software is licensed under the MIT License. + +Copyright Fedor Indutny, 2014. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to permit +persons to whom the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +*/ +var r; + +module.exports = function rand(len) { + if (!r) r = new Rand(null); + + return r.generate(len); +}; + +function Rand(rand) { + this.rand = rand; +} +module.exports.Rand = Rand; + +Rand.prototype.generate = function generate(len) { + return this._rand(len); +}; + +// Emulate crypto API using randy +Rand.prototype._rand = function _rand(n) { + if (this.rand.getBytes) return this.rand.getBytes(n); + + var res = new Uint8Array(n); + for (var i = 0; i < res.length; i++) res[i] = this.rand.getByte(); + return res; +}; + +if (typeof self === "object") { + if (self.crypto && self.crypto.getRandomValues) { + // Modern browsers + Rand.prototype._rand = function _rand(n) { + var arr = new Uint8Array(n); + self.crypto.getRandomValues(arr); + return arr; + }; + } else if (self.msCrypto && self.msCrypto.getRandomValues) { + // IE + Rand.prototype._rand = function _rand(n) { + var arr = new Uint8Array(n); + self.msCrypto.getRandomValues(arr); + return arr; + }; + + // Safari's WebWorkers do not have `crypto` + } else if (typeof window === "object") { + // Old junk + Rand.prototype._rand = function () { + throw new Error("Not implemented yet"); + }; + } +} diff --git a/src/compat/crypto/ecdh.ts b/src/compat/crypto/ecdh.ts new file mode 100644 index 00000000..a27f1ff5 --- /dev/null +++ b/src/compat/crypto/ecdh.ts @@ -0,0 +1,172 @@ +// @ts-nocheck +// Ported from pinned workerd crypto_dh.ts; see LICENSE-APACHE and LICENSE-3RD-PARTY.md. +import { Buffer } from "node:buffer"; +import { NativeECDH } from "./native-crypto.js"; +import { validateString, validateOneOf } from "../net/validators.js"; +import { ERR_INVALID_ARG_TYPE } from "../net/errors.js"; +import { isArrayBufferView } from "../util/types/index.js"; +const cryptoImpl = { ECDHHandle: NativeECDH }; +const kHandle = Symbol("kHandle"); +export interface ECDH { + [kHandle]: cryptoImpl.ECDHHandle; + computeSecret( + otherPublicKey: string | ArrayBufferView | ArrayBuffer, + inputEncoding?: string, + outputEncoding?: string, + ): Buffer | string; + generateKeys(encoding?: string, format?: string): Buffer | string; + getPrivateKey(encoding?: string): Buffer | string; + getPublicKey(encoding?: string, format?: string): Buffer | string; + setPrivateKey( + key: string | ArrayBufferView | ArrayBuffer, + encoding?: string, + ): void; +} + +export const ECDH = function (this: ECDH, curveName: string) { + if (!(this instanceof ECDH)) { + return new ECDH(curveName); + } + validateString(curveName, "curveName"); + this[kHandle] = new cryptoImpl.ECDHHandle(curveName); + return this; +} as unknown as { + new (curveName: string): ECDH; +}; + +// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access +ECDH.prototype.computeSecret = function ( + this: ECDH, + otherPublicKey: string | ArrayBufferView | ArrayBuffer, + inputEncoding?: string, + outputEncoding?: string, +): Buffer | string { + if (typeof otherPublicKey === "string") { + otherPublicKey = Buffer.from(otherPublicKey, inputEncoding); + } + if (!isArrayBufferView(otherPublicKey)) { + throw new ERR_INVALID_ARG_TYPE( + "otherPublicKey", + ["string", "Buffer", "TypedArray", "DataView"], + otherPublicKey, + ); + } + if (inputEncoding != null) { + validateString(inputEncoding, "inputEncoding"); + } + if (outputEncoding != null) { + validateString(outputEncoding, "outputEncoding"); + } + const ret = this[kHandle].computeSecret(otherPublicKey); + if (typeof outputEncoding === "string") { + return Buffer.from(ret).toString(outputEncoding); + } + return Buffer.from(ret); +}; + +// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access +ECDH.prototype.generateKeys = function ( + this: ECDH, + encoding?: string, + format?: string, +): Buffer | string { + if (encoding != null) { + validateString(encoding, "encoding"); + } + if (format != null) { + validateOneOf(format, "format", ["compressed", "uncompressed", "hybrid"]); + } + this[kHandle].generateKeys(); + return this.getPublicKey(encoding, format); +}; + +// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access +ECDH.prototype.getPrivateKey = function ( + this: ECDH, + encoding?: string, +): Buffer | string { + if (encoding != null) { + validateString(encoding, "encoding"); + } + const pvt = this[kHandle].getPrivateKey(); + if (typeof encoding === "string") { + return Buffer.from(pvt).toString(encoding); + } + return Buffer.from(pvt); +}; + +// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access +ECDH.prototype.getPublicKey = function ( + this: ECDH, + encoding?: string, + format: ECDHFormat = "uncompressed", +): Buffer | string { + if (encoding != null) { + validateString(encoding, "encoding"); + } + validateOneOf(format, "format", ["compressed", "uncompressed", "hybrid"]); + const pub = this[kHandle].getPublicKey(format); + if (typeof encoding === "string") { + return Buffer.from(pub).toString(encoding); + } + return Buffer.from(pub); +}; + +// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access +ECDH.prototype.setPrivateKey = function ( + this: ECDH, + key: string | ArrayBufferView | ArrayBuffer, + encoding?: string, +): void { + if (encoding != null) { + validateString(encoding, "encoding"); + } + if (typeof key === "string") { + key = Buffer.from(key, encoding); + } + if (!isArrayBufferView(key)) { + throw new ERR_INVALID_ARG_TYPE( + "key", + ["string", "Buffer", "TypedArray", "DataView"], + key, + ); + } + this[kHandle].setPrivateKey(key); +}; + +// eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-member-access +(ECDH as any).convertKey = function ( + key: string | ArrayBufferView | ArrayBuffer, + curve: string, + inputEncoding?: string, + outputEncoding?: string, + format: ECDHFormat = "uncompressed", +): Buffer | string { + if (typeof key === "string") { + key = Buffer.from(key, inputEncoding); + } + if (!isArrayBufferView(key)) { + throw new ERR_INVALID_ARG_TYPE( + "key", + ["string", "Buffer", "TypedArray", "DataView"], + key, + ); + } + validateString(curve, "curve"); + if (inputEncoding != null) { + validateString(inputEncoding, "inputEncoding"); + } + if (outputEncoding != null) { + validateString(outputEncoding, "outputEncoding"); + } + validateOneOf(format, "format", ["compressed", "uncompressed", "hybrid"]); + const ret = cryptoImpl.ECDHHandle.convertKey(key, curve, format); + if (typeof outputEncoding === "string") { + return Buffer.from(ret).toString(outputEncoding); + } + return Buffer.from(ret); +}; + +export function createECDH(curveName: string): ECDH { + return new ECDH(curveName); +} diff --git a/src/compat/crypto/hkdf.ts b/src/compat/crypto/hkdf.ts new file mode 100644 index 00000000..5f7ed0c4 --- /dev/null +++ b/src/compat/crypto/hkdf.ts @@ -0,0 +1,85 @@ +import { secretMaterial } from "./keys.js"; +// RFC 5869 extract-and-expand, using the existing HMAC implementation. +import { Buffer } from "node:buffer"; +// @ts-expect-error dependency has no declarations +import original from "crypto-browserify/index.js"; +import { bytes, validateInteger } from "./validation.js"; +import { validateString, validateFunction } from "../net/validators.js"; +import { ERR_OUT_OF_RANGE } from "../net/errors.js"; +function parameters( + digest: string, + key: unknown, + salt: unknown, + info: unknown, + length: number, +) { + validateString(digest, "digest"); + const ikm = bytes(secretMaterial(key), "ikm"), + s = bytes(salt, "salt"), + i = bytes(info, "info"); + validateInteger(length, "length", 0, 2147483647); + if (i.byteLength > 1024) + throw new ERR_OUT_OF_RANGE( + "info", + "must not contain more than 1024 bytes", + i.byteLength, + ); + return { digest, ikm, s, i, length }; +} +function derive({ + digest, + ikm, + s, + i, + length, +}: ReturnType): ArrayBuffer { + const prk = original.createHmac(digest, s).update(ikm).digest(); + if (length > 255 * prk.length) + throw Object.assign(new RangeError("Invalid key length"), { + code: "ERR_CRYPTO_INVALID_KEYLEN", + }); + const output = Buffer.alloc(length); + let previous = Buffer.alloc(0); + try { + for (let offset = 0, counter = 1; offset < length; counter++) { + previous = original + .createHmac(digest, prk) + .update(previous) + .update(i) + .update(Buffer.from([counter])) + .digest(); + const size = Math.min(previous.length, length - offset); + output.set(previous.subarray(0, size), offset); + offset += size; + } + return new Uint8Array(output).buffer; + } finally { + prk.fill(0); + previous.fill(0); + } +} +export function hkdfSync( + digest: string, + key: unknown, + salt: unknown, + info: unknown, + length: number, +) { + return derive(parameters(digest, key, salt, info, length)); +} +export function hkdf( + digest: string, + key: unknown, + salt: unknown, + info: unknown, + length: number, + callback: (error: unknown, value?: ArrayBuffer) => void, +) { + const args = parameters(digest, key, salt, info, length); + validateFunction(callback, "callback"); + const result = new Promise((resolve) => resolve(derive(args))); + result.then( + (value) => callback(null, value), + (error) => callback(error), + ); +} diff --git a/src/compat/crypto/index.cjs b/src/compat/crypto/index.cjs new file mode 100644 index 00000000..7c72726b --- /dev/null +++ b/src/compat/crypto/index.cjs @@ -0,0 +1 @@ +module.exports = require("./index.js").default; diff --git a/src/compat/crypto/index.ts b/src/compat/crypto/index.ts new file mode 100644 index 00000000..a6f94e70 --- /dev/null +++ b/src/compat/crypto/index.ts @@ -0,0 +1,140 @@ +import { ECDH, createECDH } from "./ecdh.js"; +export { ECDH, createECDH }; +import * as signatures from "./signatures.js"; +export * from "./signatures.js"; +import * as prime from "./prime.js"; +export * from "./prime.js"; +import * as asymmetric from "./asymmetric.js"; +export { + createPrivateKey, + createPublicKey, + generateKeyPair, + generateKeyPairSync, + diffieHellman, + timingSafeEqual, +} from "./asymmetric.js"; +import * as keys from "./keys.js"; +export { + KeyObject, + SecretKeyObject, + PublicKeyObject, + PrivateKeyObject, + createSecretKey, + generateKey, + generateKeySync, +} from "./keys.js"; +import * as metadata from "./metadata.js"; +export * from "./metadata.js"; +// Existing algorithms retain the dependency implementation. Additional APIs +// below are separately verified against the pinned Workers profile. +// @ts-expect-error crypto-browserify has no declarations +import original from "crypto-browserify/index.js"; +import { hkdf, hkdfSync } from "./hkdf.js"; +import { randomInt, randomUUID } from "./random.js"; +import { scrypt, scryptSync } from "./scrypt.js"; +import { validateString } from "../net/validators.js"; +import { bytes } from "./validation.js"; +export { hkdf, hkdfSync, randomInt, randomUUID, scrypt, scryptSync }; +export const { + prng, + pseudoRandomBytes, + rng, + randomBytes, + Hash, + createHash, + getHashes, + pbkdf2, + pbkdf2Sync, + Cipher, + createCipher, + Decipher, + createDecipher, + getCiphers, + listCiphers, + DiffieHellmanGroup, + createDiffieHellmanGroup, + getDiffieHellman, + createDiffieHellman, + DiffieHellman, + randomFill, + randomFillSync, + createCredentials, + constants, +} = original; +import { + Hmac, + Cipheriv, + Decipheriv, + createHmac, + createCipheriv, + createDecipheriv, +} from "./symmetric.js"; +export { + Hmac, + Cipheriv, + Decipheriv, + createHmac, + createCipheriv, + createDecipheriv, +}; +import { + publicEncrypt, + privateEncrypt, + publicDecrypt, + privateDecrypt, +} from "./rsa.js"; +export { publicEncrypt, privateEncrypt, publicDecrypt, privateDecrypt }; +export const webcrypto = globalThis.crypto; +export const subtle = webcrypto.subtle; +export const getRandomValues = webcrypto.getRandomValues.bind(webcrypto); +export const CryptoKey = globalThis.CryptoKey; +export function hash( + algorithm: string, + data: unknown, + outputEncoding: string = "hex", +) { + validateString(algorithm, "algorithm"); + validateString(outputEncoding, "outputEncoding"); + const result = original + .createHash(algorithm) + .update(bytes(data, "data")) + .digest(); + return outputEncoding === "buffer" ? result : result.toString(outputEncoding); +} +export default { + ...original, + ...metadata, + ...asymmetric, + ...signatures, + ...prime, + publicEncrypt, + privateEncrypt, + publicDecrypt, + privateDecrypt, + ECDH, + createECDH, + KeyObject: keys.KeyObject, + SecretKeyObject: keys.SecretKeyObject, + PublicKeyObject: keys.PublicKeyObject, + PrivateKeyObject: keys.PrivateKeyObject, + createSecretKey: keys.createSecretKey, + generateKey: keys.generateKey, + generateKeySync: keys.generateKeySync, + Hmac, + createHmac, + Cipheriv, + createCipheriv, + Decipheriv, + createDecipheriv, + hkdf, + hkdfSync, + webcrypto, + subtle, + getRandomValues, + CryptoKey, + randomInt, + randomUUID, + hash, + scrypt, + scryptSync, +}; diff --git a/src/compat/crypto/key-formats.ts b/src/compat/crypto/key-formats.ts new file mode 100644 index 00000000..1c524092 --- /dev/null +++ b/src/compat/crypto/key-formats.ts @@ -0,0 +1,143 @@ +import { Buffer } from "node:buffer"; +import { NativeKey } from "./native-crypto.js"; +// DER encodings follow RFC 5208/5915/8410; JWK members follow RFC 7518/8037. +const curves: Record = { + "P-256": { oid: "2a8648ce3d030107", size: 32, native: "prime256v1" }, + "P-384": { oid: "2b81040022", size: 48, native: "secp384r1" }, + "P-521": { oid: "2b81040023", size: 66, native: "secp521r1" }, + secp256k1: { oid: "2b8104000a", size: 32, native: "secp256k1" }, +}; +export function der(tag: number, ...parts: Uint8Array[]): Buffer { + const data = Buffer.concat(parts); + let length: number[] = []; + if (data.length < 128) length = [data.length]; + else { + let size = data.length; + while (size) { + length.unshift(size & 255); + size = Math.floor(size / 256); + } + length.unshift(128 + length.length); + } + return Buffer.concat([Buffer.from([tag, ...length]), data]); +} +export function integer(bytes: Uint8Array): Buffer { + let offset = 0; + while (offset < bytes.length - 1 && bytes[offset] === 0) offset++; + const data = bytes.subarray(offset); + return der(2, ...(data[0] & 128 ? [Buffer.from([0]), data] : [data])); +} +function field(jwk: any, name: string, size?: number): Buffer { + if (typeof jwk[name] !== "string") + throw new TypeError(`Missing JWK member: ${name}`); + const bytes = Buffer.from(jwk[name], "base64url"); + if (size !== undefined && bytes.length !== size) + throw new TypeError(`Invalid JWK member length: ${name}`); + if (!bytes.length) throw new TypeError(`Empty JWK member: ${name}`); + return bytes; +} +export function importJwk(jwk: any, privateKey: boolean): NativeKey { + if (jwk?.kty === "RSA") { + const names = privateKey + ? ["n", "e", "d", "p", "q", "dp", "dq", "qi"] + : ["n", "e"]; + return NativeKey.parse( + der( + 48, + ...(privateKey ? [integer(Buffer.from([0]))] : []), + ...names.map((name) => integer(field(jwk, name))), + ), + false, + privateKey, + ); + } + if (jwk?.kty === "EC") { + const curve = curves[jwk.crv]; + if (!curve) throw new TypeError("Unsupported JWK curve"); + const oid = der(6, Buffer.from(curve.oid, "hex")); + const point = Buffer.concat([ + Buffer.from([4]), + field(jwk, "x", curve.size), + field(jwk, "y", curve.size), + ]); + const bits = der(3, Buffer.from([0]), point); + const data = privateKey + ? der( + 48, + integer(Buffer.from([1])), + der(4, field(jwk, "d", curve.size)), + der(160, oid), + der(161, bits), + ) + : der( + 48, + der(48, der(6, Buffer.from("2a8648ce3d0201", "hex")), oid), + bits, + ); + return NativeKey.parse(data, false, privateKey); + } + if (jwk?.kty === "OKP" && ["Ed25519", "X25519"].includes(jwk.crv)) { + const algorithm = der( + 48, + der(6, Buffer.from([43, 101, jwk.crv === "Ed25519" ? 112 : 110])), + ); + const data = privateKey + ? der( + 48, + integer(Buffer.from([0])), + algorithm, + der(4, der(4, field(jwk, "d", 32))), + ) + : der(48, algorithm, der(3, Buffer.from([0]), field(jwk, "x", 32))); + return NativeKey.parse(data, false, privateKey); + } + throw new TypeError("Unsupported JWK key type"); +} +function encode(bytes: Uint8Array, size?: number): string { + if (size !== undefined && bytes.length < size) + bytes = Buffer.concat([Buffer.alloc(size - bytes.length), bytes]); + return Buffer.from(bytes).toString("base64url"); +} +export function exportJwk(key: NativeKey, privateKey: boolean): any { + if (key.type === "rsa") { + const result: any = { + kty: "RSA", + n: encode(key.parameter("n")), + e: encode(key.parameter("e")), + }; + if (privateKey) + for (const [name, param] of [ + ["d", "d"], + ["p", "rsa-factor1"], + ["q", "rsa-factor2"], + ["dp", "rsa-exponent1"], + ["dq", "rsa-exponent2"], + ["qi", "rsa-coefficient1"], + ]) + result[name] = encode(key.parameter(param)); + return result; + } + if (key.type === "ec") { + const found = Object.entries(curves).find( + ([, value]) => value.native === key.group, + ); + if (!found) throw new TypeError("Unsupported JWK curve"); + const [crv, curve] = found; + return { + kty: "EC", + crv, + x: encode(key.parameter("qx"), curve.size), + y: encode(key.parameter("qy"), curve.size), + ...(privateKey ? { d: encode(key.parameter("priv"), curve.size) } : {}), + }; + } + if (["ed25519", "x25519"].includes(key.type)) + return { + kty: "OKP", + ...(key.type === "ed25519" ? { alg: "EdDSA" } : {}), + crv: key.type === "ed25519" ? "Ed25519" : "X25519", + x: encode(key.raw(false)), + ...(privateKey ? { d: encode(key.raw(true)) } : {}), + }; + throw new TypeError("Unsupported JWK key type"); +} diff --git a/src/compat/crypto/key-state.ts b/src/compat/crypto/key-state.ts new file mode 100644 index 00000000..3e771d07 --- /dev/null +++ b/src/compat/crypto/key-state.ts @@ -0,0 +1,12 @@ +import type { NativeKey } from "./native-crypto.js"; +// Shared branding without importing crypto's algorithm dependency graph. +export interface KeyState { + type: "secret" | "private" | "public"; + bytes?: Uint8Array; + asymmetric?: NativeKey; + native?: CryptoKey; +} +export const keyStates = new WeakMap(); +export function isKeyObject(value: unknown): boolean { + return typeof value === "object" && value !== null && keyStates.has(value); +} diff --git a/src/compat/crypto/keys.ts b/src/compat/crypto/keys.ts new file mode 100644 index 00000000..4b70f2ee --- /dev/null +++ b/src/compat/crypto/keys.ts @@ -0,0 +1,248 @@ +import { exportJwk } from "./key-formats.js"; +// API behavior follows workerd@5358e3d337336eaf696a48bc1563d808b10feba5 +// crypto_keys.ts (Apache-2.0 and Node MIT). Host CryptoKey export is an explicit +// synchronous-engine boundary; adapter-created secret keys own copied bytes. +import { Buffer } from "node:buffer"; +import { keyStates, type KeyState } from "./key-state.js"; +import { bytes, validateInteger } from "./validation.js"; +import { + validateObject, + validateString, + validateOneOf, +} from "../net/validators.js"; +import { ERR_INVALID_ARG_TYPE } from "../net/errors.js"; +function state(value: object): KeyState { + const result = keyStates.get(value); + if (!result) throw new ERR_INVALID_ARG_TYPE("key", "KeyObject", value); + return result; +} +function boundary(): never { + throw Object.assign( + new Error( + "Synchronous export of a host CryptoKey is unavailable in this WebView runtime", + ), + { code: "ERR_METHOD_NOT_IMPLEMENTED" }, + ); +} +export function create( + type: KeyState["type"], + value: Omit, +): KeyObject { + const Class = + type === "secret" + ? SecretKeyObject + : type === "public" + ? PublicKeyObject + : PrivateKeyObject; + const result = Object.create(Class.prototype) as KeyObject; + keyStates.set(result, { type, ...value }); + return result; +} +export abstract class KeyObject { + constructor() { + throw new Error("Illegal constructor"); + } + static from(key: CryptoKey): KeyObject { + if (!(key instanceof globalThis.CryptoKey)) + throw new ERR_INVALID_ARG_TYPE("key", "CryptoKey", key); + return create(key.type, { native: key }); + } + abstract get type(): KeyState["type"]; + get [Symbol.toStringTag]() { + return "KeyObject"; + } + export(options: any = {}): any { + validateObject(options, "options"); + if (options.format === undefined) options.format = "buffer"; + validateString(options.format, "options.format"); + if (options.type !== undefined) + validateString(options.type, "options.type"); + const current = state(this); + if (current.asymmetric) { + if (options.format === "jwk") + return exportJwk(current.asymmetric, current.type === "private"); + validateOneOf(options.format, "options.format", ["pem", "der"]); + validateOneOf( + options.type, + "options.type", + current.type === "private" + ? ["pkcs1", "pkcs8", "sec1"] + : ["pkcs1", "spki"], + ); + if (options.cipher !== undefined) + validateString(options.cipher, "options.cipher"); + const passphrase = + options.passphrase === undefined + ? undefined + : bytes(options.passphrase, "options.passphrase"); + const result = current.asymmetric.export( + current.type === "private", + options.format === "pem", + options.type, + options.cipher, + passphrase, + ); + return options.format === "pem" + ? new TextDecoder().decode(result) + : Buffer.from(result); + } + const data = current.bytes; + if (!data) return boundary(); + if (options.format === "buffer") return Buffer.from(data); + if (options.format === "jwk") + return { + kty: "oct", + ext: true, + k: Buffer.from(data) + .toString("base64") + .replace(/=/g, "") + .replace(/\+/g, "-") + .replace(/\//g, "_"), + }; + throw new TypeError( + `Invalid format for secret key export: ${options.format}`, + ); + } + equals(other: KeyObject): boolean { + if (other == null) + throw new TypeError("Cannot read properties of null or undefined"); + const a = state(this), + b = keyStates.get(other); + if (this === other || (a.native && a.native === b?.native)) return true; + if (a.type !== other?.type) return false; + if (!b) + throw new ERR_INVALID_ARG_TYPE("otherKeyObject", "KeyObject", other); + if (a.asymmetric && b.asymmetric) return a.asymmetric.equals(b.asymmetric); + if (!a.bytes || !b.bytes) return boundary(); + if (a.bytes.length !== b.bytes.length) return false; + let difference = 0; + for (let i = 0; i < a.bytes.length; i++) + difference |= a.bytes[i] ^ b.bytes[i]; + return difference === 0; + } +} +export class SecretKeyObject extends KeyObject { + get type(): "secret" { + return "secret"; + } + override export(options?: any) { + return super.export(options); + } + get symmetricKeySize() { + const key = state(this); + return ( + key.bytes?.length ?? ((key.native?.algorithm as any)?.length ?? 0) | 0 + ); + } + [Symbol.for("nodejs.util.inspect.custom")]() { + return `SecretKeyObject { size: ${this.symmetricKeySize} }`; + } +} +abstract class AsymmetricKeyObject extends KeyObject { + get asymmetricKeyType() { + const key = state(this).asymmetric; + if (!key) return boundary(); + return key.type; + } + get asymmetricKeyDetails() { + const key = state(this).asymmetric; + if (!key) return boundary(); + if (key.type === "rsa") + return { + modulusLength: key.bits, + publicExponent: BigInt( + "0x" + Buffer.from(key.parameter("e")).toString("hex"), + ), + }; + if (key.type === "ec") return { namedCurve: key.group }; + return {}; + } + toCryptoKey() { + throw Object.assign( + new Error("The toCryptoKey method is not implemented"), + { code: "ERR_METHOD_NOT_IMPLEMENTED" }, + ); + } +} +export class PublicKeyObject extends AsymmetricKeyObject { + get type(): "public" { + return "public"; + } + override export(options?: any) { + return super.export(options); + } +} +export class PrivateKeyObject extends AsymmetricKeyObject { + get type(): "private" { + return "private"; + } + override export(options?: any) { + return super.export(options); + } +} +export function createSecretKey( + value: unknown, + encoding?: BufferEncoding, +): SecretKeyObject { + if ( + typeof value !== "string" && + !(value instanceof ArrayBuffer) && + !ArrayBuffer.isView(value) && + !( + typeof SharedArrayBuffer !== "undefined" && + value instanceof SharedArrayBuffer + ) + ) + throw new ERR_INVALID_ARG_TYPE( + "key", + ["string", "ArrayBuffer", "TypedArray", "DataView"], + value, + ); + const data = + typeof value === "string" + ? Buffer.from(value, encoding) + : typeof SharedArrayBuffer !== "undefined" && + value instanceof SharedArrayBuffer + ? new Uint8Array(value) + : bytes(value, "key"); + return create("secret", { bytes: new Uint8Array(data) }) as SecretKeyObject; +} +export function secretMaterial(value: unknown): any { + if (typeof value !== "object" || value === null || !keyStates.has(value)) + return value; + const key = state(value); + if (key.type !== "secret") throw new TypeError("Expected a secret key"); + if (!key.bytes) return boundary(); + return Buffer.from(key.bytes); +} +export function generateKeySync( + type: string, + options: { length: number }, +): SecretKeyObject { + validateOneOf(type, "type", ["hmac", "aes"]); + validateObject(options, "options"); + if (type === "hmac") + validateInteger(options.length, "options.length", 8, 65536); + else validateOneOf(options.length, "options.length", [128, 192, 256]); + const material = new Uint8Array(Math.floor(options.length / 8)); + globalThis.crypto.getRandomValues(material); + return createSecretKey(material); +} +export function generateKey( + type: string, + options: { length: number }, + callback: (error: unknown, key?: SecretKeyObject) => void, +): void { + let key: SecretKeyObject | undefined, failure: unknown; + try { + key = generateKeySync(type, options); + } catch (error) { + failure = error; + } + queueMicrotask(() => callback(failure ?? null, key)); +} + +export { isKeyObject } from "./key-state.js"; +export function getKeyObjectHandle(key: KeyObject) { + return key; +} diff --git a/src/compat/crypto/metadata.ts b/src/compat/crypto/metadata.ts new file mode 100644 index 00000000..0a574ee8 --- /dev/null +++ b/src/compat/crypto/metadata.ts @@ -0,0 +1,22 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under Apache-2.0: https://opensource.org/licenses/Apache-2.0 +// Adapted from workerd@5358e3d337336eaf696a48bc1563d808b10feba5. +export function getCurves(): string[] { + return ["secp224r1", "prime256v1", "secp384r1", "secp521r1"]; +} +export function secureHeapUsed(): Record { + return { total: 0, used: 0, utilization: 0, min: 0 }; +} +function unavailable(method: string): never { + throw Object.assign(new Error(`The ${method} method is not implemented`), { + code: "ERR_METHOD_NOT_IMPLEMENTED", + }); +} +export function setEngine(_engine: string, _flags?: number): never { + return unavailable("setEngine"); +} +export function setFips(_enabled: boolean): never { + return unavailable("setFips"); +} +// Do not copy Workers' fips=true: this adapter uses JavaScript algorithms, +// not Workers' FIPS backend. That capability remains an explicit boundary. diff --git a/src/compat/crypto/native-crypto.build.json b/src/compat/crypto/native-crypto.build.json new file mode 100644 index 00000000..57cb824c --- /dev/null +++ b/src/compat/crypto/native-crypto.build.json @@ -0,0 +1,39 @@ +{ + "revisions": { + "emsdk": "e4fe26ef59168ff44f4c23c466e497bf60b3411e", + "openssl": "45e844fa2a14ec92d146bd8f5778ac130b6625fb" + }, + "configure": [ + "linux-generic32", + "--cross-compile-prefix=", + "no-asm", + "no-shared", + "no-threads", + "no-tests", + "no-dso", + "no-module", + "no-apps", + "no-docs", + "no-sock", + "no-ui-console", + "no-autoload-config", + "no-engine", + "no-afalgeng", + "--with-rand-seed=getrandom", + "-O3" + ], + "flags": [ + "-O3", + "-Wno-deprecated-declarations", + "-sSTANDALONE_WASM=1", + "-sALLOW_MEMORY_GROWTH=1", + "-sFILESYSTEM=0", + "-sASSERTIONS=0", + "-sMALLOC=emmalloc", + "-sABORTING_MALLOC=0", + "--no-entry", + "-sEXPORTED_FUNCTIONS=[\"_malloc\",\"_free\"]" + ], + "bindingSha256": "bc0d4d182a4bf3d67cce1517d779ebb46b67f49e418340b62cd9cdd08f02c376", + "sha256": "b0c0ed73e8d1b50e7092e48e13088e34b46742571b3488f4b99f71d109e62f20" +} diff --git a/src/compat/crypto/native-crypto.c b/src/compat/crypto/native-crypto.c new file mode 100644 index 00000000..cf018578 --- /dev/null +++ b/src/compat/crypto/native-crypto.c @@ -0,0 +1,218 @@ +// OpenSSL bridge owned by cf-workers-native (MIT). +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define API EMSCRIPTEN_KEEPALIVE +static unsigned char *output; +static size_t output_length; +static void clear_output(void) { OPENSSL_clear_free(output, output_length); output=NULL; output_length=0; } +static int save_bio(BIO *bio) { + char *data; long size=BIO_get_mem_data(bio,&data); + if(size<0) return 0; + clear_output(); output=OPENSSL_memdup(data,(size_t)size);output_length=(size_t)size; + return output != NULL; +} +API int wk_init(void) { return OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG,NULL); } +API void wk_output_clear(void) { clear_output(); } +API void *wk_output(void) { return output; } +API size_t wk_output_length(void) { return output_length; } +API unsigned long wk_error(void) { return ERR_get_error(); } +API const char *wk_error_reason(unsigned long error) { return ERR_reason_error_string(error); } +API int wk_equal(const void *a,const void *b,size_t size) { return CRYPTO_memcmp(a,b,size)==0; } +struct password_input {const unsigned char *bytes;int length;}; +static int password_callback(char *buffer,int size,int writing,void *opaque) { + (void)writing;struct password_input *password=opaque; + if(!password || password->length>size)return -1; + if(password->length)memcpy(buffer,password->bytes,password->length); + return password->length; +} +API EVP_PKEY *wk_key_parse(const unsigned char *data,int size,int pem,int private_key,const unsigned char *password,int password_length) { + ERR_clear_error(); BIO *bio=BIO_new_mem_buf(data,size); if(!bio)return NULL; + struct password_input pass={password,password_length}; + EVP_PKEY *key=NULL; + if(pem) { + key=private_key?PEM_read_bio_PrivateKey(bio,NULL,password_callback,&pass):PEM_read_bio_PUBKEY(bio,NULL,NULL,NULL); + } else { + const unsigned char *cursor=data; + key=private_key?d2i_AutoPrivateKey(NULL,&cursor,size):d2i_PUBKEY(NULL,&cursor,size); + if(!key && private_key) { ERR_clear_error();BIO_reset(bio);key=d2i_PKCS8PrivateKey_bio(bio,NULL,password_callback,&pass); } + if(!key && !private_key) { cursor=data; RSA *rsa=d2i_RSAPublicKey(NULL,&cursor,size);if(rsa){key=EVP_PKEY_new();if(!key || !EVP_PKEY_assign_RSA(key,rsa)){RSA_free(rsa);EVP_PKEY_free(key);key=NULL;}} } + } + BIO_free(bio);return key; +} +API void wk_key_free(EVP_PKEY *key) { EVP_PKEY_free(key); } +API const char *wk_key_type(EVP_PKEY *key) { return EVP_PKEY_get0_type_name(key); } +API int wk_key_bits(EVP_PKEY *key) { return EVP_PKEY_get_bits(key); } +API int wk_key_equal(EVP_PKEY *a,EVP_PKEY *b) { return EVP_PKEY_eq(a,b); } +API int wk_key_export(EVP_PKEY *key,int private_key,int pem,int type,const char *cipher_name,const char *password,int password_length) { + ERR_clear_error();BIO *bio=BIO_new(BIO_s_mem());if(!bio)return 0; + const EVP_CIPHER *cipher=cipher_name && *cipher_name?EVP_get_cipherbyname(cipher_name):NULL; + if(cipher_name && *cipher_name && !cipher){BIO_free(bio);return 0;} + int ok=0; + if(private_key) { + if(type==0) ok=pem?PEM_write_bio_PKCS8PrivateKey(bio,key,cipher,(char *)password,password_length,NULL,NULL):i2d_PKCS8PrivateKey_bio(bio,key,cipher,(char *)password,password_length,NULL,NULL); + else if(type==1) {RSA *rsa=EVP_PKEY_get1_RSA(key);if(rsa){ok=pem?PEM_write_bio_RSAPrivateKey(bio,rsa,cipher,(const unsigned char *)password,password_length,NULL,NULL):i2d_RSAPrivateKey_bio(bio,rsa);RSA_free(rsa);}} + else if(type==2) {EC_KEY *ec=EVP_PKEY_get1_EC_KEY(key);if(ec){ok=pem?PEM_write_bio_ECPrivateKey(bio,ec,cipher,(const unsigned char *)password,password_length,NULL,NULL):i2d_ECPrivateKey_bio(bio,ec);EC_KEY_free(ec);}} + } else { + if(type==1) {RSA *rsa=EVP_PKEY_get1_RSA(key);if(rsa){ok=pem?PEM_write_bio_RSAPublicKey(bio,rsa):i2d_RSAPublicKey_bio(bio,rsa);RSA_free(rsa);}} + else ok=pem?PEM_write_bio_PUBKEY(bio,key):i2d_PUBKEY_bio(bio,key); + } + if(ok)ok=save_bio(bio);BIO_free(bio);return ok; +} +API EVP_PKEY *wk_key_generate(const char *type,int bits,const char *curve,unsigned long exponent) { + ERR_clear_error();EVP_PKEY_CTX *ctx=EVP_PKEY_CTX_new_from_name(NULL,type,NULL);if(!ctx)return NULL; + EVP_PKEY *key=NULL;int ok=EVP_PKEY_keygen_init(ctx)>0; + if(ok && (!strcmp(type,"RSA") || !strcmp(type,"RSA-PSS")))ok=EVP_PKEY_CTX_set_rsa_keygen_bits(ctx,bits)>0; + if(ok && (!strcmp(type,"RSA") || !strcmp(type,"RSA-PSS"))) { BIGNUM *e=BN_new();ok=e && BN_set_word(e,exponent) && EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx,e)>0;BN_free(e); } + if(ok && (!strcmp(type,"EC") || !strcmp(type,"DH")))ok=EVP_PKEY_CTX_set_group_name(ctx,curve)>0; + if(ok)ok=EVP_PKEY_generate(ctx,&key)>0; + EVP_PKEY_CTX_free(ctx);if(!ok){EVP_PKEY_free(key);return NULL;}return key; +} +static int signature_width(EVP_PKEY *key) { + if(EVP_PKEY_is_a(key,"EC"))return (EVP_PKEY_get_bits(key)+7)/8; + if(EVP_PKEY_is_a(key,"DSA")){BIGNUM *q=NULL;if(!EVP_PKEY_get_bn_param(key,OSSL_PKEY_PARAM_FFC_Q,&q))return 0;int size=BN_num_bytes(q);BN_free(q);return size;} + return 0; +} +API int wk_sign(EVP_PKEY *key,const char *digest,const unsigned char *data,size_t length,int padding,int saltlen,int p1363) { + ERR_clear_error();EVP_MD_CTX *ctx=EVP_MD_CTX_new();if(!ctx)return 0;EVP_PKEY_CTX *pctx=NULL; + int ok=EVP_DigestSignInit_ex(ctx,&pctx,digest && *digest?digest:NULL,NULL,NULL,key,NULL)>0; + if(ok && padding)ok=EVP_PKEY_CTX_set_rsa_padding(pctx,padding)>0; + if(ok && padding==RSA_PKCS1_PSS_PADDING)ok=EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,saltlen)>0; + size_t size=0;if(ok)ok=EVP_DigestSign(ctx,NULL,&size,data,length)>0; + clear_output();if(ok){output=OPENSSL_malloc(size);output_length=size;ok=output && EVP_DigestSign(ctx,output,&output_length,data,length)>0;} + if(ok && p1363 && signature_width(key)) { + int width=signature_width(key);const unsigned char *cursor=output;ECDSA_SIG *signature=d2i_ECDSA_SIG(NULL,&cursor,output_length); + unsigned char *raw=OPENSSL_malloc(2*width);const BIGNUM *r,*s; + if(!signature || !raw)ok=0; + else {ECDSA_SIG_get0(signature,&r,&s);ok=BN_bn2binpad(r,raw,width)==width && BN_bn2binpad(s,raw+width,width)==width;} + ECDSA_SIG_free(signature);clear_output();if(ok){output=raw;output_length=2*width;}else OPENSSL_clear_free(raw,2*width); + } + EVP_MD_CTX_free(ctx);return ok; +} +API int wk_verify(EVP_PKEY *key,const char *digest,const unsigned char *data,size_t length,const unsigned char *signature,size_t signature_length,int padding,int saltlen,int p1363) { + ERR_clear_error();EVP_MD_CTX *ctx=EVP_MD_CTX_new();if(!ctx)return -1;EVP_PKEY_CTX *pctx=NULL; + int ok=EVP_DigestVerifyInit_ex(ctx,&pctx,digest && *digest?digest:NULL,NULL,NULL,key,NULL)>0; + if(ok && padding)ok=EVP_PKEY_CTX_set_rsa_padding(pctx,padding)>0; + if(ok && padding==RSA_PKCS1_PSS_PADDING)ok=EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,saltlen)>0; + unsigned char *converted=NULL; + if(ok && p1363 && signature_width(key)) { + int width=signature_width(key); + if(signature_length!=(size_t)(2*width)){EVP_MD_CTX_free(ctx);return 0;} + ECDSA_SIG *value=ECDSA_SIG_new();BIGNUM *r=BN_bin2bn(signature,width,NULL),*s=BN_bin2bn(signature+width,width,NULL); + if(!value || !r || !s || !ECDSA_SIG_set0(value,r,s)){ECDSA_SIG_free(value);BN_free(r);BN_free(s);EVP_MD_CTX_free(ctx);return -1;} + int length=i2d_ECDSA_SIG(value,&converted);ECDSA_SIG_free(value);if(length<=0){EVP_MD_CTX_free(ctx);return -1;} + signature=converted;signature_length=(size_t)length; + } + int result=ok?EVP_DigestVerify(ctx,signature,signature_length,data,length):-1;OPENSSL_free(converted);EVP_MD_CTX_free(ctx);return result; +} + +API int wk_derive(EVP_PKEY *key,EVP_PKEY *peer) { + ERR_clear_error();EVP_PKEY_CTX *ctx=EVP_PKEY_CTX_new(key,NULL);if(!ctx)return 0; + size_t size=0;int ok=EVP_PKEY_derive_init(ctx)>0 && EVP_PKEY_derive_set_peer(ctx,peer)>0 && EVP_PKEY_derive(ctx,NULL,&size)>0; + clear_output();if(ok){output=OPENSSL_malloc(size);output_length=size;ok=output && EVP_PKEY_derive(ctx,output,&output_length)>0;} + EVP_PKEY_CTX_free(ctx);return ok; +} +API int wk_key_parameter(EVP_PKEY *key,const char *name) { + ERR_clear_error();BIGNUM *bn=NULL;if(!EVP_PKEY_get_bn_param(key,name,&bn))return 0; + clear_output();output_length=BN_num_bytes(bn);output=OPENSSL_malloc(output_length?output_length:1); + int ok=output!=NULL;if(ok)BN_bn2bin(bn,output);BN_clear_free(bn);return ok; +} +API int wk_key_group(EVP_PKEY *key) { + char name[100];size_t size=0;if(!EVP_PKEY_get_utf8_string_param(key,OSSL_PKEY_PARAM_GROUP_NAME,name,sizeof(name),&size))return 0; + clear_output();output=(unsigned char *)OPENSSL_strdup(name);output_length=size;return output!=NULL; +} +API int wk_key_raw(EVP_PKEY *key,int private_key) { + size_t size=0;int ok=private_key?EVP_PKEY_get_raw_private_key(key,NULL,&size):EVP_PKEY_get_raw_public_key(key,NULL,&size); + clear_output();if(ok){output=OPENSSL_malloc(size);output_length=size;ok=output && (private_key?EVP_PKEY_get_raw_private_key(key,output,&output_length):EVP_PKEY_get_raw_public_key(key,output,&output_length));}return ok; +} +API int wk_prime_check(const unsigned char *data,int length,int checks) { + ERR_clear_error();BIGNUM *value=BN_bin2bn(data,length,NULL);BN_CTX *ctx=BN_CTX_new(); + int result=value && ctx?BN_is_prime_ex(value,checks,ctx,NULL):-1;BN_clear_free(value);BN_CTX_free(ctx);return result; +} +API int wk_prime_generate(int bits,int safe,const unsigned char *add,int add_length,const unsigned char *rem,int rem_length) { + ERR_clear_error();BIGNUM *a=add?BN_bin2bn(add,add_length,NULL):NULL,*r=rem?BN_bin2bn(rem,rem_length,NULL):NULL,*prime=BN_new();BN_CTX *ctx=BN_CTX_new(); + int ok=prime && ctx && (!add || a) && (!rem || r) && BN_generate_prime_ex2(prime,bits,safe,a,r,NULL,ctx); + clear_output();if(ok){output_length=BN_num_bytes(prime);output=OPENSSL_malloc(output_length?output_length:1);ok=output!=NULL;if(ok)BN_bn2bin(prime,output);} + BN_clear_free(a);BN_clear_free(r);BN_clear_free(prime);BN_CTX_free(ctx);return ok; +} +API EVP_MD_CTX *wk_digest_new(const char *algorithm) { + ERR_clear_error();const EVP_MD *md=EVP_get_digestbyname(algorithm);EVP_MD_CTX *ctx=EVP_MD_CTX_new(); + if(!md || !ctx || EVP_DigestInit_ex(ctx,md,NULL)!=1){EVP_MD_CTX_free(ctx);return NULL;}return ctx; +} +API void wk_digest_free(EVP_MD_CTX *ctx) {EVP_MD_CTX_free(ctx);} +API int wk_digest_update(EVP_MD_CTX *ctx,const unsigned char *data,size_t length) {return EVP_DigestUpdate(ctx,data,length);} +API int wk_digest_final(EVP_MD_CTX *ctx) { + unsigned int length=EVP_MAX_MD_SIZE;clear_output();output=OPENSSL_malloc(length);if(!output)return 0; + output_length=length;if(EVP_DigestFinal_ex(ctx,output,&length)!=1){clear_output();return 0;}output_length=length;return 1; +} +API int wk_sign_hash(EVP_PKEY *key,const char *digest,const unsigned char *data,size_t length,int padding,int saltlen) { + ERR_clear_error();EVP_PKEY_CTX *ctx=EVP_PKEY_CTX_new(key,NULL);if(!ctx)return 0; + int ok=EVP_PKEY_sign_init(ctx)>0 && EVP_PKEY_CTX_set_signature_md(ctx,EVP_get_digestbyname(digest))>0; + if(ok && padding)ok=EVP_PKEY_CTX_set_rsa_padding(ctx,padding)>0; + if(ok && padding==RSA_PKCS1_PSS_PADDING)ok=EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx,saltlen)>0; + size_t size=0;if(ok)ok=EVP_PKEY_sign(ctx,NULL,&size,data,length)>0; + clear_output();if(ok){output=OPENSSL_malloc(size);output_length=size;ok=output && EVP_PKEY_sign(ctx,output,&output_length,data,length)>0;}EVP_PKEY_CTX_free(ctx);return ok; +} +API int wk_verify_hash(EVP_PKEY *key,const char *digest,const unsigned char *data,size_t length,const unsigned char *signature,size_t signature_length,int padding,int saltlen) { + ERR_clear_error();EVP_PKEY_CTX *ctx=EVP_PKEY_CTX_new(key,NULL);if(!ctx)return -1; + int ok=EVP_PKEY_verify_init(ctx)>0 && EVP_PKEY_CTX_set_signature_md(ctx,EVP_get_digestbyname(digest))>0; + if(ok && padding)ok=EVP_PKEY_CTX_set_rsa_padding(ctx,padding)>0; + if(ok && padding==RSA_PKCS1_PSS_PADDING)ok=EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx,saltlen)>0; + int result=ok?EVP_PKEY_verify(ctx,signature,signature_length,data,length):-1;EVP_PKEY_CTX_free(ctx);return result; +} +API EC_KEY *wk_ec_new(const char *curve) {return EC_KEY_new_by_curve_name(OBJ_sn2nid(curve));} +API void wk_ec_free(EC_KEY *key) {EC_KEY_free(key);} +API int wk_ec_generate(EC_KEY *key) {return EC_KEY_generate_key(key);} +API int wk_ec_set_private(EC_KEY *key,const unsigned char *data,int length) { + const EC_GROUP *group=EC_KEY_get0_group(key);BIGNUM *private=BN_bin2bn(data,length,NULL),*order=BN_new();EC_POINT *point=EC_POINT_new(group); + int ok=private && order && point && EC_GROUP_get_order(group,order,NULL) && !BN_is_zero(private) && BN_cmp(private,order)<0; + if(ok)ok=EC_POINT_mul(group,point,private,NULL,NULL,NULL) && EC_KEY_set_private_key(key,private) && EC_KEY_set_public_key(key,point); + BN_clear_free(private);BN_free(order);EC_POINT_free(point);return ok; +} +static int save_point(const EC_GROUP *group,const EC_POINT *point,int format) { + clear_output();size_t size=EC_POINT_point2oct(group,point,format,NULL,0,NULL);if(!size)return 0; + output=OPENSSL_malloc(size);output_length=size;return output && EC_POINT_point2oct(group,point,format,output,size,NULL)==size; +} +API int wk_ec_public(EC_KEY *key,int format) {const EC_POINT *point=EC_KEY_get0_public_key(key);return point && save_point(EC_KEY_get0_group(key),point,format);} +API int wk_ec_private(EC_KEY *key) { + const BIGNUM *private=EC_KEY_get0_private_key(key);if(!private)return 0;clear_output();output_length=BN_num_bytes(private);output=OPENSSL_malloc(output_length);return output && BN_bn2bin(private,output)==output_length; +} +API int wk_ec_secret(EC_KEY *key,const unsigned char *data,size_t length) { + if(EC_KEY_check_key(key)!=1)return -2;const EC_GROUP *group=EC_KEY_get0_group(key);EC_POINT *point=EC_POINT_new(group); + if(!point || !EC_POINT_oct2point(group,point,data,length,NULL) || EC_POINT_is_at_infinity(group,point) || EC_POINT_is_on_curve(group,point,NULL)!=1){EC_POINT_free(point);return -3;} + clear_output();output_length=(EC_GROUP_get_degree(group)+7)/8;output=OPENSSL_malloc(output_length);int ok=output && ECDH_compute_key(output,output_length,point,key,NULL)>0;EC_POINT_free(point);return ok; +} +API int wk_ec_convert(EC_KEY *key,const unsigned char *data,size_t length,int format) { + const EC_GROUP *group=EC_KEY_get0_group(key);EC_POINT *point=EC_POINT_new(group); + int ok=point && EC_POINT_oct2point(group,point,data,length,NULL) && save_point(group,point,format);EC_POINT_free(point);return ok; +} +API int wk_rsa(EVP_PKEY *key,int operation,const unsigned char *data,size_t length,int padding,const char *hash,const unsigned char *label,size_t label_length,int has_label) { + ERR_clear_error();EVP_PKEY_CTX *ctx=EVP_PKEY_CTX_new(key,NULL);if(!ctx)return -1; + int initialized=operation==0?EVP_PKEY_encrypt_init(ctx):operation==1?EVP_PKEY_decrypt_init(ctx):operation==2?EVP_PKEY_sign_init(ctx):EVP_PKEY_verify_recover_init(ctx); + int status=-1;if(initialized<=0)goto done; + const EVP_MD *digest=NULL; + if(operation<2){digest=EVP_get_digestbyname(hash);if(!digest){status=-2;goto done;}} + if(EVP_PKEY_CTX_set_rsa_padding(ctx,padding)<=0){status=-3;goto done;} + if(digest && padding==RSA_PKCS1_OAEP_PADDING){ + if(EVP_PKEY_CTX_set_rsa_oaep_md(ctx,digest)!=1){status=-4;goto done;} + if(EVP_PKEY_CTX_set_rsa_mgf1_md(ctx,digest)!=1){status=-5;goto done;} + } + if(operation<2 && has_label){if(padding!=RSA_PKCS1_OAEP_PADDING){status=-6;goto done;}unsigned char *copy=OPENSSL_malloc(label_length?label_length:1);if(!copy){status=-6;goto done;}if(label_length)memcpy(copy,label,label_length); + if(EVP_PKEY_CTX_set0_rsa_oaep_label(ctx,copy,label_length)!=1){OPENSSL_free(copy);status=-6;goto done;} + } + int (*cipher)(EVP_PKEY_CTX*,unsigned char*,size_t*,const unsigned char*,size_t)=operation==0?EVP_PKEY_encrypt:operation==1?EVP_PKEY_decrypt:operation==2?EVP_PKEY_sign:EVP_PKEY_verify_recover; + size_t size=0;if(cipher(ctx,NULL,&size,data,length)!=1){status=-7;goto done;} + clear_output();output=OPENSSL_malloc(size?size:1);output_length=size; + if(!output || cipher(ctx,output,&output_length,data,length)!=1){clear_output();status=-8;goto done;} + status=1; + done: EVP_PKEY_CTX_free(ctx);return status; +} diff --git a/src/compat/crypto/native-crypto.ts b/src/compat/crypto/native-crypto.ts new file mode 100644 index 00000000..25e9a8a9 --- /dev/null +++ b/src/compat/crypto/native-crypto.ts @@ -0,0 +1,485 @@ +import binary from "./native-crypto.wasm"; +type API = Record any> & { + memory: WebAssembly.Memory; +}; +let instance: API | undefined; +const encoder = new TextEncoder(), + decoder = new TextDecoder(); +function library(): API { + if (instance) return instance; + let api: API; + const wasi = { + random_get(pointer: number, length: number) { + const bytes = new Uint8Array(api.memory.buffer, pointer, length); + for (let offset = 0; offset < length; offset += 65536) + globalThis.crypto.getRandomValues( + bytes.subarray(offset, Math.min(length, offset + 65536)), + ); + return 0; + }, + clock_time_get(clock: number, _precision: bigint, pointer: number) { + const milliseconds = clock === 1 ? performance.now() : Date.now(); + new DataView(api.memory.buffer).setBigUint64( + pointer, + BigInt(Math.floor(milliseconds * 1e6)), + true, + ); + return 0; + }, + environ_sizes_get(count: number, size: number) { + const view = new DataView(api.memory.buffer); + view.setUint32(count, 0, true); + view.setUint32(size, 0, true); + return 0; + }, + environ_get() { + return 0; + }, + fd_read() { + return 8; + }, + fd_write() { + return 8; + }, + fd_seek() { + return 8; + }, + fd_close() { + return 8; + }, + }; + api = new WebAssembly.Instance( + new WebAssembly.Module(binary as BufferSource), + { + env: { + emscripten_notify_memory_growth() {}, + __syscall_getdents64() { + return -52; + }, + }, + wasi_snapshot_preview1: wasi, + }, + ).exports as API; + api._initialize(); + if (!api.wk_init()) throw new Error("Crypto backend initialization failed"); + instance = api; + return api; +} +function text(pointer: number): string { + const data = new Uint8Array(library().memory.buffer); + let end = pointer; + while (data[end]) end++; + return decoder.decode(data.subarray(pointer, end)); +} +function error(): Error { + const api = library(), + code = api.wk_error(); + return Object.assign( + new Error( + code ? text(api.wk_error_reason(code)) : "Cryptographic operation failed", + ), + { code: "ERR_CRYPTO_OPERATION_FAILED" }, + ); +} +function inputs( + values: (string | Uint8Array | null | undefined)[], + operation: (api: API, pointers: number[]) => T, +): T { + const api = library(), + allocated: { pointer: number; length: number }[] = []; + try { + const pointers = values.map((value) => { + if (value == null) return 0; + const data = + typeof value === "string" + ? encoder.encode(value + "\0") + : new Uint8Array(value.buffer, value.byteOffset, value.byteLength); + const pointer = api.malloc(Math.max(1, data.length)); + if (!pointer) throw new RangeError("Memory limit exceeded"); + allocated.push({ pointer, length: data.length }); + new Uint8Array(api.memory.buffer).set(data, pointer); + return pointer; + }); + return operation(api, pointers); + } finally { + for (const { pointer, length } of allocated) { + new Uint8Array(api.memory.buffer, pointer, length).fill(0); + api.free(pointer); + } + } +} +function result(api: API): Uint8Array { + try { + return new Uint8Array( + api.memory.buffer, + api.wk_output(), + api.wk_output_length(), + ).slice(); + } finally { + api.wk_output_clear(); + } +} +const released = new FinalizationRegistry((pointer) => + library().wk_key_free(pointer), +); +export class NativeKey { + rsa(operation: number, data: Uint8Array, options: any): Uint8Array { + if (this.type !== "rsa") + throw new Error("publicEncrypt() currently only supports RSA keys"); + const label = options.oaepLabel; + return inputs( + [ + data, + options.oaepHash, + label instanceof ArrayBuffer ? new Uint8Array(label) : label, + ], + (api, [p, h, l]) => { + const status = api.wk_rsa( + this.pointer, + operation, + p, + data.byteLength, + options.padding, + h, + l, + label?.byteLength ?? 0, + +(label !== undefined), + ); + if (status !== 1) + throw new Error( + ( + { + [-1]: + operation === 0 || operation === 2 + ? "Failed to init for encryption" + : "Failed to init for decryption", + [-2]: "Unsupported hash digest", + [-3]: "Failed to set the padding", + [-4]: "Failed to set the digest", + [-5]: "Failed to set the mgf1 digest", + [-6]: "Failed to set the OAEP label", + [-7]: "Failed to determine output size", + [-8]: "Failed to cipher/decipher", + } as Record + )[status], + ); + return result(api); + }, + ); + } + constructor(private pointer: number) { + if (!pointer) throw error(); + released.register(this, pointer, this); + } + dispose() { + if (this.pointer) { + released.unregister(this); + library().wk_key_free(this.pointer); + this.pointer = 0; + } + } + private handle() { + if (!this.pointer) throw new Error("Key has been disposed"); + return this.pointer; + } + static parse( + data: Uint8Array, + pem: boolean, + privateKey: boolean, + password?: Uint8Array, + ) { + return inputs( + [data, password], + (api, [p, pass]) => + new NativeKey( + api.wk_key_parse( + p, + data.length, + +pem, + +privateKey, + pass, + password?.length ?? 0, + ), + ), + ); + } + static generate(type: string, bits = 0, curve?: string, exponent = 65537) { + return inputs( + [type, curve], + (api, [t, c]) => new NativeKey(api.wk_key_generate(t, bits, c, exponent)), + ); + } + get type() { + return text(library().wk_key_type(this.handle())).toLowerCase(); + } + get bits() { + return library().wk_key_bits(this.handle()) as number; + } + equals(other: NativeKey) { + return library().wk_key_equal(this.handle(), other.handle()) === 1; + } + export( + privateKey: boolean, + pem: boolean, + type: "pkcs8" | "pkcs1" | "sec1" | "spki", + cipher?: string, + password?: Uint8Array, + ) { + return inputs([cipher, password], (api, [c, p]) => { + if ( + !api.wk_key_export( + this.handle(), + +privateKey, + +pem, + type === "pkcs1" ? 1 : type === "sec1" ? 2 : 0, + c, + p, + password?.length ?? 0, + ) + ) + throw error(); + return result(api); + }); + } + parameter(name: string) { + return inputs([name], (api, [p]) => { + if (!api.wk_key_parameter(this.handle(), p)) throw error(); + return result(api); + }); + } + raw(privateKey: boolean) { + const api = library(); + if (!api.wk_key_raw(this.handle(), +privateKey)) throw error(); + return result(api); + } + get group() { + const api = library(); + if (!api.wk_key_group(this.handle())) throw error(); + return decoder.decode(result(api)); + } + sign( + digest: string | null, + data: Uint8Array, + padding = 0, + saltLength = -1, + p1363 = false, + ) { + return inputs([digest, data], (api, [d, p]) => { + if ( + !api.wk_sign( + this.handle(), + d, + p, + data.length, + padding, + saltLength, + +p1363, + ) + ) + throw error(); + return result(api); + }); + } + verify( + digest: string | null, + data: Uint8Array, + signature: Uint8Array, + padding = 0, + saltLength = -1, + p1363 = false, + ) { + return inputs([digest, data, signature], (api, [d, p, s]) => { + const value = api.wk_verify( + this.handle(), + d, + p, + data.length, + s, + signature.length, + padding, + saltLength, + +p1363, + ); + if (value < 0) throw error(); + return value === 1; + }); + } + signHash(digest: string, data: Uint8Array, padding = 0, saltLength = -1) { + return inputs([digest, data], (api, [d, p]) => { + if ( + !api.wk_sign_hash(this.handle(), d, p, data.length, padding, saltLength) + ) + throw error(); + return result(api); + }); + } + verifyHash( + digest: string, + data: Uint8Array, + signature: Uint8Array, + padding = 0, + saltLength = -1, + ) { + return inputs([digest, data, signature], (api, [d, p, s]) => { + const valid = api.wk_verify_hash( + this.handle(), + d, + p, + data.length, + s, + signature.length, + padding, + saltLength, + ); + if (valid < 0) throw error(); + return valid === 1; + }); + } + derive(peer: NativeKey) { + const api = library(); + if (!api.wk_derive(this.handle(), peer.handle())) throw error(); + return result(api); + } +} +export function nativeTimingEqual(a: Uint8Array, b: Uint8Array): boolean { + if (a.length !== b.length) + throw new RangeError("Input buffers must have the same byte length"); + return inputs( + [a, b], + (api, [ap, bp]) => api.wk_equal(ap, bp, a.length) === 1, + ); +} +export function nativePrimeCheck(data: Uint8Array, checks: number): boolean { + return inputs([data], (api, [p]) => { + const result = api.wk_prime_check(p, data.length, checks); + if (result < 0) throw new Error("Error while checking prime"); + return result === 1; + }); +} +export function nativePrimeGenerate( + bits: number, + safe: boolean, + add?: Uint8Array, + rem?: Uint8Array, +): Uint8Array { + return inputs([add, rem], (api, [a, r]) => { + if ( + !api.wk_prime_generate( + bits, + +safe, + a, + add?.length ?? 0, + r, + rem?.length ?? 0, + ) + ) + throw new Error("Error while generating prime"); + return result(api); + }); +} + +const digestReleased = new FinalizationRegistry((pointer) => + library().wk_digest_free(pointer), +); +export class NativeDigest { + private pointer: number; + constructor( + algorithm: string, + private context = "Signing", + ) { + this.pointer = inputs([algorithm], (api, [p]) => api.wk_digest_new(p)); + if (!this.pointer) throw new Error(`Unknown digest: ${algorithm}`); + digestReleased.register(this, this.pointer, this); + } + update(data: Uint8Array) { + if (!this.pointer) + throw new Error(`${this.context} context has already been finalized`); + inputs([data], (api, [p]) => { + if (!api.wk_digest_update(this.pointer, p, data.length)) throw error(); + }); + } + final() { + if (!this.pointer) + throw new Error(`${this.context} context has already been finalized`); + const api = library(); + try { + if (!api.wk_digest_final(this.pointer)) throw error(); + return result(api); + } finally { + api.wk_digest_free(this.pointer); + this.pointer = 0; + digestReleased.unregister(this); + } + } +} + +const ecReleased = new FinalizationRegistry((pointer) => + library().wk_ec_free(pointer), +); +export class NativeECDH { + private pointer: number; + constructor(curve: string) { + if (!["secp224r1", "prime256v1", "secp384r1", "secp521r1"].includes(curve)) + throw new Error("Invalid curve"); + this.pointer = inputs([curve], (api, [p]) => api.wk_ec_new(p)); + if (!this.pointer) + throw new Error("Failed to create key using named curve"); + ecReleased.register(this, this.pointer, this); + } + generateKeys() { + if (!library().wk_ec_generate(this.pointer)) + throw new Error("Failed to generate keys"); + } + getPrivateKey() { + const api = library(); + if (!api.wk_ec_private(this.pointer)) + throw new Error("Failed to get ECDH private key"); + return result(api); + } + getPublicKey(format: string) { + const api = library(); + if (!api.wk_ec_public(this.pointer, ecFormat(format))) + throw new Error("Failed to get ECDH public key"); + return result(api); + } + setPrivateKey(data: Uint8Array) { + inputs([data], (api, [p]) => { + if (!api.wk_ec_set_private(this.pointer, p, data.byteLength)) + throw new Error("Private key is not valid for specified curve."); + }); + } + computeSecret(data: Uint8Array) { + return inputs([data], (api, [p]) => { + const status = api.wk_ec_secret(this.pointer, p, data.byteLength); + if (status !== 1) + throw new Error( + status === -2 + ? "Invalid keypair" + : status === -3 + ? "Failed to set point" + : "Failed to compute ECDH key", + ); + return result(api); + }); + } + static convertKey(data: Uint8Array, curve: string, format: string) { + if (!data.byteLength) return new Uint8Array(); + const key = new NativeECDH(curve); + try { + return inputs([data], (api, [p]) => { + if ( + !api.wk_ec_convert(key.pointer, p, data.byteLength, ecFormat(format)) + ) + throw new Error("Failed to set point"); + return result(api); + }); + } finally { + library().wk_ec_free(key.pointer); + ecReleased.unregister(key); + } + } +} +function ecFormat(format: string) { + if (format === "hybrid") throw new Error("Failed to get public key length"); + return format === "compressed" ? 2 : 4; +} diff --git a/src/compat/crypto/native-crypto.wasm b/src/compat/crypto/native-crypto.wasm new file mode 100755 index 0000000000000000000000000000000000000000..b3cea63b527c5734fa253601855725be115aeb8d GIT binary patch literal 1750462 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ü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

LL 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%0DenR)lCvI86sdb`v~5F&G3#THe#%ls$AE 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%0DG{X;Dvu0b0yd?_DHkENqfa1bM6N8EF3>3}F9 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

>6dn8-a<_ED%v!4on> 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⋙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 A-v9sr literal 0 HcmV?d00001 diff --git a/src/compat/crypto/prime.ts b/src/compat/crypto/prime.ts new file mode 100644 index 00000000..d02bfaa7 --- /dev/null +++ b/src/compat/crypto/prime.ts @@ -0,0 +1,250 @@ +// Adapted from pinned workerd crypto_random.ts (Apache-2.0 / Node MIT). +import { Buffer } from "node:buffer"; +import { + validateObject, + validateFunction, + validateBoolean, + validateInt32, +} from "../net/validators.js"; +import { ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } from "../net/errors.js"; +import { isAnyArrayBuffer, isArrayBufferView } from "../util/types/index.js"; +import { nativePrimeCheck, nativePrimeGenerate } from "./native-crypto.js"; +function view(value: any): Uint8Array { + return ArrayBuffer.isView(value) + ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) + : new Uint8Array(value); +} +function arrayBufferToUnsignedBigInt(value: any): bigint { + const hex = Buffer.from(view(value)).toString("hex"); + return hex ? BigInt("0x" + hex) : 0n; +} +const cryptoImpl = { + checkPrimeSync(candidate: ArrayBufferView, checks: number) { + const data = view(candidate); + if (checks > 64) throw new RangeError("Invalid number of checks"); + if (data.length > 1024) + throw new RangeError("checkPrime candidate exceeds maximum size"); + return nativePrimeCheck(data, checks); + }, + randomPrime( + bits: number, + safe: boolean, + add?: ArrayBufferView, + rem?: ArrayBufferView, + ): ArrayBuffer { + if (bits > 8192) + throw new RangeError("generatePrime size exceeds maximum (8192 bits)"); + if (add !== undefined) { + const a = arrayBufferToUnsignedBigInt(add), + r = rem === undefined ? undefined : arrayBufferToUnsignedBigInt(rem); + if ( + !( + (a === 12n && r === 11n) || + (a === 24n && r === 23n) || + (a === 60n && r === 59n) + ) + ) + throw new RangeError("Invalid values for add and rem"); + if (a.toString(2).length > bits) + throw new RangeError( + "options.add must not be bigger than size of the requested prime", + ); + } + return nativePrimeGenerate( + bits, + safe, + add === undefined ? undefined : view(add), + rem === undefined ? undefined : view(rem), + ).buffer as ArrayBuffer; + }, +}; +export type PrimeNum = ArrayBuffer | ArrayBufferView | Buffer | bigint; +export interface GeneratePrimeOptions { + add?: PrimeNum; + rem?: PrimeNum; + safe?: boolean; + bigint?: boolean; +} + +export interface CheckPrimeOptions { + checks?: number; +} + +export type GeneratePrimeCallback = ( + err: Error | null, + prime?: bigint | ArrayBuffer, +) => void; +export type CheckPrimeCallback = (err: Error | null, prime?: boolean) => void; + +function processGeneratePrimeOptions(options: GeneratePrimeOptions): { + add: ArrayBufferView; + rem: ArrayBufferView; + safe: boolean; + bigint: boolean; +} { + validateObject(options, "options"); + const { safe = false, bigint = false } = options; + let { add, rem } = options; + validateBoolean(safe, "options.safe"); + validateBoolean(bigint, "options.bigint"); + + if (add !== undefined) { + if (typeof add === "bigint") { + add = unsignedBigIntToBuffer(add, "options.add"); + } else if (!isAnyArrayBuffer(add) && !isArrayBufferView(add)) { + throw new ERR_INVALID_ARG_TYPE( + "options.add", + ["ArrayBuffer", "TypedArray", "Buffer", "DataView", "bigint"], + add, + ); + } + } + + if (rem !== undefined) { + if (typeof rem === "bigint") { + rem = unsignedBigIntToBuffer(rem, "options.rem"); + } else if (!isAnyArrayBuffer(rem) && !isArrayBufferView(rem)) { + throw new ERR_INVALID_ARG_TYPE( + "options.rem", + ["ArrayBuffer", "TypedArray", "Buffer", "DataView", "bigint"], + rem, + ); + } + } + + return { + safe, + bigint, + add: add as ArrayBufferView, + rem: rem as ArrayBufferView, + }; +} + +export function generatePrimeSync( + size: number, + options: GeneratePrimeOptions = {}, +): bigint | ArrayBuffer { + validateInt32(size, "size", 1); + const { safe, bigint, add, rem } = processGeneratePrimeOptions(options); + + const primeBuf = cryptoImpl.randomPrime(size, safe, add, rem); + return bigint ? arrayBufferToUnsignedBigInt(primeBuf) : primeBuf; +} + +export function generatePrime( + size: number, + options: GeneratePrimeOptions, + callback: GeneratePrimeCallback, +): void; +export function generatePrime( + size: number, + callback: GeneratePrimeCallback, +): void; +export function generatePrime( + size: number, + options: GeneratePrimeOptions | GeneratePrimeCallback, + callback?: GeneratePrimeCallback, +): void { + validateInt32(size, "size", 1); + if (typeof options === "function") { + callback = options; + options = {}; + } + validateFunction(callback, "callback"); + + const { safe, bigint, add, rem } = processGeneratePrimeOptions(options); + + new Promise((res, rej) => { + try { + const primeBuf = cryptoImpl.randomPrime(size, safe, add, rem); + res(bigint ? arrayBufferToUnsignedBigInt(primeBuf) : primeBuf); + } catch (err) { + rej(err as Error); + } + }).then( + (val: bigint | ArrayBuffer): void => { + callback(null, val); + }, + (err: unknown): void => { + callback(err as Error); + }, + ); +} + +function unsignedBigIntToBuffer(bigint: bigint, name: string): Buffer { + if (bigint < 0) { + throw new ERR_OUT_OF_RANGE(name, ">= 0", bigint); + } + + const hex = bigint.toString(16); + const padded = hex.padStart(hex.length + (hex.length % 2), "0"); + return Buffer.from(padded, "hex"); +} + +function validateCandidate(candidate: PrimeNum): Buffer { + if (typeof candidate === "bigint") + candidate = unsignedBigIntToBuffer(candidate, "candidate"); + if (!isAnyArrayBuffer(candidate) && !isArrayBufferView(candidate)) { + throw new ERR_INVALID_ARG_TYPE( + "candidate", + ["ArrayBuffer", "TypedArray", "Buffer", "DataView", "bigint"], + candidate, + ); + } + return candidate as Buffer; +} + +function validateChecks(options: CheckPrimeOptions): number { + const { checks = 0 } = options; + // The checks option is unsigned but must fit into a signed 32-bit integer for OpenSSL. + validateInt32(checks, "options.checks", 0); + return checks; +} + +export function checkPrimeSync( + candidate: PrimeNum, + options: CheckPrimeOptions = {}, +): boolean { + candidate = validateCandidate(candidate); + validateObject(options, "options"); + const checks = validateChecks(options); + return cryptoImpl.checkPrimeSync(candidate as ArrayBufferView, checks); +} + +export function checkPrime( + candidate: PrimeNum, + options: CheckPrimeOptions, + callback: CheckPrimeCallback, +): void; +export function checkPrime( + candidate: PrimeNum, + callback: CheckPrimeCallback, +): void; +export function checkPrime( + candidate: PrimeNum, + options: CheckPrimeOptions | CheckPrimeCallback, + callback?: CheckPrimeCallback, +): void { + candidate = validateCandidate(candidate); + if (typeof options === "function") { + callback = options; + options = {}; + } + validateObject(options, "options"); + validateFunction(callback, "callback"); + const checks = validateChecks(options); + new Promise((res, rej) => { + try { + res(cryptoImpl.checkPrimeSync(candidate as ArrayBufferView, checks)); + } catch (err) { + rej(err as Error); + } + }).then( + (val: boolean): void => { + callback(null, val); + }, + (err: unknown): void => { + callback(err); + }, + ); +} diff --git a/src/compat/crypto/random.ts b/src/compat/crypto/random.ts new file mode 100644 index 00000000..4b8cfa1f --- /dev/null +++ b/src/compat/crypto/random.ts @@ -0,0 +1,154 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// Adapted from workerd@5358e3d337336eaf696a48bc1563d808b10feba5. +import { Buffer } from "node:buffer"; +import type { RandomUUIDOptions } from "node:crypto"; +import { validateInteger } from "./validation.js"; +import { validateBoolean, validateObject } from "../net/validators.js"; +import { ERR_OUT_OF_RANGE } from "../net/errors.js"; +// Cache size stays below the Web Crypto per-call limit. +function randomFillSync(buffer: Uint8Array) { + return globalThis.crypto.getRandomValues(buffer as Uint8Array); +} +const RAND_MAX = 0xffff_ffff_ffff; +// Cache random data to use in randomInt. The cache size must be evenly +// divisible by 6 because each attempt to obtain a random int uses 6 bytes. +const randomCache = Buffer.alloc(6 * 1024); +let randomCacheOffset = 0; +let initialized = false; + +function getRandomInt(min: number, max: number): number { + if (!initialized) { + randomFillSync(randomCache); + initialized = true; + } + // First we generate a random int between [0..range) + const range = max - min; + + if (!(range <= RAND_MAX)) { + throw new ERR_OUT_OF_RANGE( + `max${max ? "" : " - min"}`, + `<= ${RAND_MAX}`, + range, + ); + } + + // For (x % range) to produce an unbiased value greater than or equal to 0 and + // less than range, x must be drawn randomly from the set of integers greater + // than or equal to 0 and less than randLimit. + const randLimit = RAND_MAX - (RAND_MAX % range); + + // If we don't have a callback, or if there is still data in the cache, we can + // do this synchronously, which is super fast. + while (randomCacheOffset <= randomCache.length) { + if (randomCacheOffset === randomCache.length) { + // This might block the thread for a bit, but we are in sync mode. + randomFillSync(randomCache); + randomCacheOffset = 0; + } + + const x = randomCache.readUIntBE(randomCacheOffset, 6); + randomCacheOffset += 6; + if (x < randLimit) { + return (x % range) + min; + } + } + return 0; // Should be unreachable. +} + +export type RandomIntCallback = (err: Error | null, n?: number) => void; +export function randomInt(max: number): number; +export function randomInt(min: number, max: number): number; +export function randomInt(max: number, callback: RandomIntCallback): void; +export function randomInt( + min: number, + max: number, + callback: RandomIntCallback, +): void; +export function randomInt( + minOrMax: number, + maxOrCallback?: number | RandomIntCallback, + callback?: RandomIntCallback, +): number | undefined { + let min = 0; + let max = 0; + if (typeof callback === "function") { + validateInteger(minOrMax, "min"); + validateInteger(maxOrCallback, "max"); + min = minOrMax; + max = maxOrCallback; + } else if (typeof maxOrCallback === "function") { + min = 0; + validateInteger(minOrMax, "max"); + max = minOrMax; + callback = maxOrCallback; + } else if (arguments.length === 2) { + validateInteger(minOrMax, "min"); + validateInteger(maxOrCallback, "max"); + min = minOrMax; + max = maxOrCallback; + } else { + min = 0; + validateInteger(minOrMax, "max"); + max = minOrMax; + } + + if (min >= max) { + throw new ERR_OUT_OF_RANGE("min", "min < max", min); + } + + if (callback != null) { + new Promise((res) => { + res(getRandomInt(min, max)); + }).then( + (n: number): void => { + callback(null, n); + }, + (err: unknown): void => { + callback(err as Error); + }, + ); + } else { + return getRandomInt(min, max); + } + + return undefined; +} + +export function randomUUID(options?: RandomUUIDOptions): string { + // While we do not actually use the entropy cache, we go ahead and validate + // the input parameters as Node.js does. + if (options !== undefined) { + validateObject(options, "options"); + if (options.disableEntropyCache !== undefined) { + validateBoolean( + options.disableEntropyCache, + "options.disableEntropyCache", + ); + } + } + return crypto.randomUUID(); +} diff --git a/src/compat/crypto/rsa.ts b/src/compat/crypto/rsa.ts new file mode 100644 index 00000000..4c244037 --- /dev/null +++ b/src/compat/crypto/rsa.ts @@ -0,0 +1,235 @@ +// @ts-nocheck +// Pinned workerd crypto_cipher.ts; LICENSE-APACHE and LICENSE-3RD-PARTY.md. +import { Buffer } from "node:buffer"; +import { validateNumber, validateString } from "../net/validators.js"; +import { ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS } from "../net/errors.js"; +import { ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE } from "./sign-errors.js"; +import { isAnyArrayBuffer, isArrayBufferView } from "../util/types/index.js"; +import { isKeyObject, getKeyObjectHandle } from "./keys.js"; +import { createPrivateKey, createPublicKey } from "./asymmetric.js"; +import { keyStates } from "./key-state.js"; +const kRsaPkcs1Padding = 1; +function operate(operation, key, data, options) { + const handle = keyStates.get(key)?.asymmetric; + if (!handle) + throw Object.assign( + new Error( + "Synchronous access to opaque host key material is unavailable", + ), + { code: "ERR_METHOD_NOT_IMPLEMENTED" }, + ); + if (data instanceof ArrayBuffer) data = new Uint8Array(data); + return handle.rsa(operation, data, options); +} +const cryptoImpl = { + publicEncrypt: (...args) => operate(0, ...args), + privateDecrypt: (...args) => operate(1, ...args), + privateEncrypt: (...args) => operate(2, ...args), + publicDecrypt: (...args) => operate(3, ...args), +}; +function getPaddingAndHash(options: HashOptions): PublicPrivateCipherOptions { + const { + padding = kRsaPkcs1Padding, + oaepHash = "sha256", + oaepLabel, + encoding = "utf8", + } = options; + + validateNumber(padding, "options.padding"); + validateString(oaepHash, "options.oaepHash"); + + let label: ArrayBufferView | ArrayBuffer | undefined; + if (oaepLabel !== undefined) { + if (typeof oaepLabel === "string") { + label = Buffer.from(oaepLabel, encoding); + } else if (isAnyArrayBuffer(oaepLabel) || isArrayBufferView(oaepLabel)) { + label = oaepLabel; + } else { + throw new ERR_INVALID_ARG_TYPE( + "options.oaepLabel", + ["string", "Buffer", "TypedArray", "DataView", "ArrayBuffer"], + oaepLabel, + ); + } + } + + return { padding, oaepHash, oaepLabel: label }; +} + +export function privateEncrypt( + privateKey: CreateAsymmetricKeyOptions | KeyObject | CryptoKey | undefined, + buffer: string | ArrayBufferView | ArrayBuffer | undefined, +): Buffer { + if (privateKey === undefined) { + throw new ERR_MISSING_ARGS("privateKey"); + } + if (buffer === undefined) { + throw new ERR_MISSING_ARGS("buffer"); + } + const key = ((): CryptoKey => { + if (privateKey instanceof CryptoKey) { + if (privateKey.type !== "private") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE( + privateKey.type, + "private", + ); + } + return privateKey; + } else if (isKeyObject(privateKey)) { + if (privateKey.type !== "private") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE( + privateKey.type, + "private", + ); + } + return getKeyObjectHandle(privateKey); + } else { + const pvtKey = createPrivateKey(privateKey); + return getKeyObjectHandle(pvtKey); + } + })(); + if (typeof buffer === "string") { + const { encoding = "utf8" } = privateKey as { encoding?: string }; + buffer = Buffer.from(buffer, encoding); + } + + return Buffer.from( + cryptoImpl.privateEncrypt( + key, + buffer, + getPaddingAndHash(privateKey as HashOptions), + ), + ); +} + +export function privateDecrypt( + privateKey: CreateAsymmetricKeyOptions | KeyData, + buffer: string | ArrayBufferView | ArrayBuffer, +): Buffer { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (privateKey === undefined) { + throw new ERR_MISSING_ARGS("privateKey"); + } + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (buffer === undefined) { + throw new ERR_MISSING_ARGS("buffer"); + } + const key = ((): CryptoKey => { + if (privateKey instanceof CryptoKey) { + if (privateKey.type !== "private") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE( + privateKey.type, + "private", + ); + } + return privateKey; + } else if (isKeyObject(privateKey)) { + if (privateKey.type !== "private") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE( + privateKey.type, + "private", + ); + } + return getKeyObjectHandle(privateKey); + } else { + const pvtKey = createPrivateKey(privateKey as CreateAsymmetricKeyOptions); + return getKeyObjectHandle(pvtKey); + } + })(); + if (typeof buffer === "string") { + const { encoding = "utf8" } = privateKey as { encoding?: string }; + buffer = Buffer.from(buffer, encoding); + } + + return Buffer.from( + cryptoImpl.privateDecrypt( + key, + buffer, + getPaddingAndHash(privateKey as HashOptions), + ), + ); +} + +export function publicEncrypt( + key: CreateAsymmetricKeyOptions | KeyData, + buffer: string | ArrayBufferView | ArrayBuffer, +): Buffer { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (key === undefined) { + throw new ERR_MISSING_ARGS("key"); + } + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (buffer === undefined) { + throw new ERR_MISSING_ARGS("buffer"); + } + const pkey = ((): CryptoKey => { + if (key instanceof CryptoKey) { + if (key.type !== "public") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "public"); + } + return key; + } else if (isKeyObject(key)) { + if (key.type !== "public") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "public"); + } + return getKeyObjectHandle(key); + } else { + const pubKey = createPublicKey(key as CreateAsymmetricKeyOptions); + return getKeyObjectHandle(pubKey); + } + })(); + if (typeof buffer === "string") { + const { encoding = "utf8" } = key as { encoding?: string }; + buffer = Buffer.from(buffer, encoding); + } + + return Buffer.from( + cryptoImpl.publicEncrypt( + pkey, + buffer, + getPaddingAndHash(key as HashOptions), + ), + ); +} + +export function publicDecrypt( + key: CreateAsymmetricKeyOptions | KeyData, + buffer: string | ArrayBufferView | ArrayBuffer, +): Buffer { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (key === undefined) { + throw new ERR_MISSING_ARGS("key"); + } + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (buffer === undefined) { + throw new ERR_MISSING_ARGS("buffer"); + } + const pkey = ((): CryptoKey => { + if (key instanceof CryptoKey) { + if (key.type !== "public") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "public"); + } + return key; + } else if (isKeyObject(key)) { + if (key.type !== "public") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "public"); + } + return getKeyObjectHandle(key); + } else { + const pubKey = createPublicKey(key as CreateAsymmetricKeyOptions); + return getKeyObjectHandle(pubKey); + } + })(); + if (typeof buffer === "string") { + const { encoding = "utf8" } = key as { encoding?: string }; + buffer = Buffer.from(buffer, encoding); + } + + return Buffer.from( + cryptoImpl.publicDecrypt( + pkey, + buffer, + getPaddingAndHash(key as HashOptions), + ), + ); +} diff --git a/src/compat/crypto/scrypt.ts b/src/compat/crypto/scrypt.ts new file mode 100644 index 00000000..3a73fce2 --- /dev/null +++ b/src/compat/crypto/scrypt.ts @@ -0,0 +1,227 @@ +// Copyright (c) 2017-2023 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// Validation/callback behavior from pinned workerd; algorithm from scrypt-js. +import { syncScrypt } from "scrypt-js"; +import { Buffer } from "node:buffer"; +import { + validateInteger, + bytes as getArrayBufferOrView, +} from "./validation.js"; +import { validateFunction, validateUint32 } from "../net/validators.js"; +import { ERR_INVALID_ARG_VALUE } from "../net/errors.js"; +type ArrayLike = any; +const kMaxLength = 2147483647; +const cryptoImpl = { + getScrypt( + password: Uint8Array, + salt: Uint8Array, + N: number, + r: number, + p: number, + maxmem: number, + length: number, + ) { + if ( + N < 2 || + (N & (N - 1)) !== 0 || + r < 1 || + p < 1 || + 128 * N * r + 128 * r * p + 256 * r > maxmem + ) { + throw new Error("Invalid scrypt params"); + } + return new Uint8Array(syncScrypt(password, salt, N, r, p, length)).buffer; + }, +}; +export interface ValidatedScryptOptions { + password: ArrayLike; + salt: ArrayLike; + keylen: number; + N: number; + r: number; + p: number; + maxmem: number; +} + +export interface ScryptOptions { + N?: number; + r?: number; + p?: number; + maxmem?: number; + cost?: number; + blockSize?: number; + parallelization?: number; +} + +const defaults: ScryptOptions = { + N: 16384, + r: 8, + p: 1, + maxmem: 32 << 20, +}; + +function validateParameters( + password: ArrayLike, + salt: ArrayLike, + keylen: number, + options?: ScryptOptions, +): ValidatedScryptOptions { + // TODO(soon): Add support for KeyObject input. + password = getArrayBufferOrView(password, "password"); + salt = getArrayBufferOrView(salt, "salt"); + + if (password.byteLength >= kMaxLength) { + throw new ERR_INVALID_ARG_VALUE("password", password, "is too big"); + } + if (salt.byteLength >= kMaxLength) { + throw new ERR_INVALID_ARG_VALUE("salt", salt, "is too big"); + } + + validateInteger(keylen, "keylen", 0, kMaxLength); + + let { N, r, p, maxmem } = defaults; + if (options && options !== defaults) { + const has_N = options.N !== undefined; + if (has_N) { + N = options.N; + validateUint32(N, "N"); + } + if (options.cost !== undefined) { + if (has_N) throw new ERR_INVALID_ARG_VALUE("cost", options.cost); + N = options.cost; + validateUint32(N, "cost"); + } + const has_r = options.r !== undefined; + if (has_r) { + r = options.r; + validateUint32(r, "r"); + } + if (options.blockSize !== undefined) { + if (has_r) + throw new ERR_INVALID_ARG_VALUE("blockSize", options.blockSize); + r = options.blockSize; + validateUint32(r, "blockSize"); + } + const has_p = options.p !== undefined; + if (has_p) { + p = options.p; + validateUint32(p, "p"); + } + if (options.parallelization !== undefined) { + if (has_p) + throw new ERR_INVALID_ARG_VALUE( + "parallelization", + options.parallelization, + ); + p = options.parallelization; + validateUint32(p, "parallelization"); + } + if (options.maxmem !== undefined) { + maxmem = options.maxmem; + validateInteger(maxmem, "maxmem", 0); + } + if (N === 0) N = defaults.N; + if (r === 0) r = defaults.r; + if (p === 0) p = defaults.p; + if (maxmem === 0) maxmem = defaults.maxmem; + } + + return { + password, + salt, + keylen, + N: N as number, + r: r as number, + p: p as number, + maxmem: maxmem as number, + }; +} + +type Callback = (err: Error | null, derivedKey?: Buffer) => void; +type OptionsOrCallback = ScryptOptions | Callback; + +export function scrypt( + password: ArrayLike, + salt: ArrayLike, + keylen: number, + options: OptionsOrCallback, + callback: OptionsOrCallback = defaults, +): void { + if (callback === defaults) { + callback = options; + options = defaults; + } + + let N: number; + let r: number; + let p: number; + let maxmem: number; + ({ password, salt, keylen, N, r, p, maxmem } = validateParameters( + password, + salt, + keylen, + options as ScryptOptions, + )); + + validateFunction(callback, "callback"); + + new Promise((res, rej) => { + try { + res(cryptoImpl.getScrypt(password, salt, N, r, p, maxmem, keylen)); + } catch (err) { + rej(err as Error); + } + }).then( + (val: ArrayBuffer) => { + (callback as Callback)(null, Buffer.from(val)); + }, + (err: unknown) => { + (callback as Callback)(err as Error); + }, + ); +} + +export function scryptSync( + password: ArrayLike, + salt: ArrayLike, + keylen: number, + options?: ScryptOptions, +): Buffer { + let N: number; + let r: number; + let p: number; + let maxmem: number; + ({ password, salt, keylen, N, r, p, maxmem } = validateParameters( + password, + salt, + keylen, + options, + )); + + return Buffer.from( + cryptoImpl.getScrypt(password, salt, N, r, p, maxmem, keylen), + ); +} diff --git a/src/compat/crypto/sign-errors.ts b/src/compat/crypto/sign-errors.ts new file mode 100644 index 00000000..e7f7b413 --- /dev/null +++ b/src/compat/crypto/sign-errors.ts @@ -0,0 +1,17 @@ +// Adapted from workerd internal_errors.ts (Apache-2.0 / Node MIT). +import { NodeError } from "../net/error-base.js"; +export { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE } from "../net/errors.js"; +export class ERR_CRYPTO_SIGN_KEY_REQUIRED extends NodeError { + constructor() { + super("ERR_CRYPTO_SIGN_KEY_REQUIRED", "No key provided to sign"); + } +} + +export class ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE extends NodeError { + constructor(actual: string, expected: string) { + super( + "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", + `Invalid key object type ${actual}, expected ${expected}.`, + ); + } +} diff --git a/src/compat/crypto/sign-handle.ts b/src/compat/crypto/sign-handle.ts new file mode 100644 index 00000000..5d1bbfe3 --- /dev/null +++ b/src/compat/crypto/sign-handle.ts @@ -0,0 +1,149 @@ +import { Buffer } from "node:buffer"; +import { NativeDigest } from "./native-crypto.js"; +import { keyStates } from "./key-state.js"; +import { KeyObject } from "./keys.js"; +import { sign, verify } from "./asymmetric.js"; +import { der, integer } from "./key-formats.js"; +function key(value: any) { + if (value instanceof globalThis.CryptoKey) value = KeyObject.from(value); + const result = keyStates.get(value)?.asymmetric; + if (!result) + throw Object.assign( + new Error( + "Synchronous access to opaque host key material is unavailable", + ), + { code: "ERR_METHOD_NOT_IMPLEMENTED" }, + ); + return result; +} +function rawSignature(data: Uint8Array, width: number): Buffer { + let offset = 0; + const item = (tag: number) => { + if (data[offset++] !== tag) throw new Error("Invalid DER signature"); + let length = data[offset++]; + if (length & 128) { + const count = length & 127; + length = 0; + for (let i = 0; i < count; i++) length = length * 256 + data[offset++]; + } + if (offset + length > data.length) throw new Error("Invalid DER signature"); + return length; + }; + const length = item(48); + if (offset + length !== data.length) throw new Error("Invalid DER signature"); + const output = Buffer.alloc(width * 2); + for (let part = 0; part < 2; part++) { + let length = item(2); + while (length > width && data[offset] === 0) { + offset++; + length--; + } + if (length > width) throw new Error("Invalid DER signature"); + output.set( + data.subarray(offset, offset + length), + part * width + width - length, + ); + offset += length; + } + return output; +} +class SignHandle { + private hash: NativeDigest; + constructor(private algorithm: string) { + this.hash = new NativeDigest(algorithm); + } + update(data: Uint8Array) { + this.hash.update( + Buffer.from(data.buffer, data.byteOffset, data.byteLength), + ); + } + sign(value: any, padding?: number, saltLength?: number, encoding?: number) { + const native = key(value), + signed = native.signHash( + this.algorithm, + this.hash.final(), + padding, + saltLength, + ); + return encoding === 1 && native.type === "ec" + ? rawSignature(signed, Math.ceil(native.bits / 8)) + : signed; + } +} +class VerifyHandle { + private hash: NativeDigest; + constructor(private algorithm: string) { + this.hash = new NativeDigest(algorithm, "Verification"); + } + update(data: Uint8Array) { + this.hash.update( + Buffer.from(data.buffer, data.byteOffset, data.byteLength), + ); + } + verify( + value: any, + signature: Uint8Array, + padding?: number, + saltLength?: number, + encoding?: number, + ) { + const native = key(value), + hash = this.hash.final(); + if (encoding === 1 && native.type === "ec") { + const width = Math.ceil(native.bits / 8); + if (signature.length !== width * 2) return false; + signature = der( + 48, + integer(signature.subarray(0, width)), + integer(signature.subarray(width)), + ); + } + return native.verifyHash( + this.algorithm, + hash, + signature, + padding, + saltLength, + ); + } +} +export default { + SignHandle, + VerifyHandle, + signOneShot( + key: any, + algorithm: any, + data: any, + padding?: number, + saltLength?: number, + encoding?: number, + ) { + return sign(algorithm, data, { + key, + padding, + saltLength, + dsaEncoding: encoding === 1 ? "ieee-p1363" : "der", + }); + }, + verifyOneShot( + key: any, + algorithm: any, + data: any, + signature: any, + padding?: number, + saltLength?: number, + encoding?: number, + ) { + return verify( + algorithm, + data, + { + key, + padding, + saltLength, + dsaEncoding: encoding === 1 ? "ieee-p1363" : "der", + }, + signature, + ); + }, +}; diff --git a/src/compat/crypto/signatures.ts b/src/compat/crypto/signatures.ts new file mode 100644 index 00000000..631268b1 --- /dev/null +++ b/src/compat/crypto/signatures.ts @@ -0,0 +1,436 @@ +// @ts-nocheck +import { createPrivateKey, createPublicKey } from "./asymmetric.js"; +// Copyright (c) 2017-2023 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +/* TODO: the following is adopted code, enabling linting one day */ +/* eslint-disable */ + +import { + default as cryptoImpl, + type SignHandle, + type VerifyHandle, + type CreateAsymmetricKeyOptions, +} from "./sign-handle.js"; + +import { validateString } from "../net/validators.js"; + +import { Buffer } from "node:buffer"; + +import { KeyObject, isKeyObject, getKeyObjectHandle } from "./keys.js"; + +import { + ERR_CRYPTO_SIGN_KEY_REQUIRED, + ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE, + ERR_INVALID_ARG_TYPE, + ERR_INVALID_ARG_VALUE, +} from "./sign-errors.js"; + +import { Writable } from "../stream/writable.js"; +import { isArrayBufferView } from "../util/types/index.js"; + +export interface SignOptions {} + +export interface Sign extends Writable { + [kHandle]: SignHandle; + update(data: any): void; + sign(privateKey: any): any; +} +export interface Verify extends Writable { + [kHandle]: VerifyHandle; + update(data: any): void; + verify(publicKey: any, signature: any): any; +} + +const kHandle = Symbol("kHandle"); + +// Uses old-style class syntax for Node.js compatibility +export const Sign = function (this: Sign, algorithm: string, options: any) { + if (!(this instanceof Sign)) return new Sign(algorithm, options); + validateString(algorithm, "algorithm"); + this[kHandle] = new cryptoImpl.SignHandle(algorithm); + Writable.call(this, options); + return this; +} as any as { + new (algorithm: string, options?: SignOptions): Sign; +}; +Object.setPrototypeOf(Sign.prototype, Writable.prototype); +Object.setPrototypeOf(Sign, Writable); + +Sign.prototype._write = function _write( + chunk: string | ArrayBufferView, + encoding: string | undefined | null, + callback: (err?: any) => void, +) { + this.update(chunk, encoding); + callback(); +}; + +Sign.prototype.update = function ( + this: Sign, + data: string | ArrayBufferView, + encoding?: string, +) { + if (typeof data === "string") { + data = Buffer.from(data, encoding); + } + if (!isArrayBufferView(data)) { + throw new ERR_INVALID_ARG_TYPE( + "data", + ["string", "Buffer", "TypedArray", "DataView"], + data, + ); + } + this[kHandle].update(data); + return this; +}; + +function getIntOption(name: string, options: any): number | undefined { + const value = options[name]; + if (value !== undefined) { + if (value === value >> 0) { + return value; + } + throw new ERR_INVALID_ARG_VALUE(`options.${name}`, value); + } + return undefined; +} + +function getDSASignatureEncoding(options: any): number { + if (typeof options === "object") { + const { dsaEncoding = "der" } = options; + if (dsaEncoding === "der") + return 0; // kSigEncDER; + else if (dsaEncoding === "ieee-p1363") return 1; // kSigEncP1363 + throw new ERR_INVALID_ARG_VALUE("options.dsaEncoding", dsaEncoding); + } + + return 0; +} + +function getPrivateKey(options: any): CryptoKey { + if (options instanceof CryptoKey) { + return options as CryptoKey; + } else if (isKeyObject(options)) { + const keyObject = options as KeyObject; + if (keyObject.type === "secret") { + throw new ERR_INVALID_ARG_TYPE( + "options", + ["PublicKeyObject", "PrivateKeyObject", "CryptoKey", "object"], + keyObject.type, + ); + } + if (keyObject.type === "public") { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE("public", "private"); + } + return getKeyObjectHandle(keyObject); + } else { + return getKeyObjectHandle( + createPrivateKey(options as CreateAsymmetricKeyOptions), + ); + } +} + +Sign.prototype.sign = function ( + this: Sign, + options: any, + encoding?: string, +): Buffer | string { + if (!options) { + throw new ERR_CRYPTO_SIGN_KEY_REQUIRED(); + } + + const key = getPrivateKey(options); + + // Options specific to RSA + const rsaPadding = getIntOption("padding", options); + const pssSaltLength = getIntOption("saltLength", options); + + // Options specific to (EC)DSA + const dsaSigEnc = getDSASignatureEncoding(options); + + const u8 = this[kHandle].sign(key, rsaPadding, pssSaltLength, dsaSigEnc); + + const res = Buffer.from(u8.buffer, u8.byteOffset, u8.byteLength); + + if (encoding && encoding !== "buffer") { + return res.toString(encoding); + } + + return res; +}; + +// Uses old-style class syntax for Node.js compatibility +export const Verify = function (this: Verify, algorithm: string, options: any) { + if (!(this instanceof Verify)) return new Verify(algorithm, options); + validateString(algorithm, "algorithm"); + this[kHandle] = new cryptoImpl.VerifyHandle(algorithm); + Writable.call(this, options); + return this; +} as any as { + new (algorithm: string, options?: SignOptions): Verify; +}; +Object.setPrototypeOf(Verify.prototype, Writable.prototype); +Object.setPrototypeOf(Verify, Writable); + +Verify.prototype._write = function _write( + chunk: string | ArrayBufferView, + encoding: string | undefined | null, + callback: (err?: unknown) => void, +) { + this.update(chunk, encoding); + callback(); +}; + +Verify.prototype.update = function ( + this: Verify, + data: string | ArrayBufferView, + encoding?: string, +) { + if (typeof data === "string") { + data = Buffer.from(data, encoding); + } + if (!isArrayBufferView(data)) { + throw new ERR_INVALID_ARG_TYPE( + "data", + ["string", "Buffer", "TypedArray", "DataView"], + data, + ); + } + this[kHandle].update(data); + return this; +}; + +Verify.prototype.verify = function ( + this: Verify, + options: any, + signature: ArrayBufferView | string, + encoding: string = "utf8", +) { + if (!options) { + throw new ERR_CRYPTO_SIGN_KEY_REQUIRED(); + } + + let key: CryptoKey; + if (options instanceof CryptoKey) { + key = options as CryptoKey; + } else if (isKeyObject(options)) { + key = getKeyObjectHandle(options as KeyObject); + } else { + key = getKeyObjectHandle( + createPublicKey(options as CreateAsymmetricKeyOptions), + ); + } + if (!(key instanceof CryptoKey) && !isKeyObject(key)) { + throw new ERR_INVALID_ARG_TYPE( + "options", + ["KeyObject", "CryptoKey", "object"], + key, + ); + } + + // Options specific to RSA + const rsaPadding = getIntOption("padding", options); + const pssSaltLength = getIntOption("saltLength", options); + + // Options specific to (EC)DSA + const dsaSigEnc = getDSASignatureEncoding(options); + + if (typeof signature === "string") { + signature = Buffer.from(signature, encoding); + } + + return this[kHandle].verify( + key, + signature, + rsaPadding, + pssSaltLength, + dsaSigEnc, + ); +}; + +export function createSign(algorithm: string, options: any) { + return new Sign(algorithm, options); +} + +export function createVerify(algorithm: string, options: any) { + return new Verify(algorithm, options); +} + +type SignCallback = (err: any, signature?: Buffer) => void; +type VerifyCallback = (err: any, valid?: boolean) => void; + +export function sign( + algorithm: string | null | undefined, + data: BufferSource, + options: any, + callback?: SignCallback, +): Buffer | void { + if (algorithm != null) { + validateString(algorithm, "algorithm"); + } else { + algorithm = undefined; + } + if (!isArrayBufferView(data)) { + throw new ERR_INVALID_ARG_TYPE( + "data", + ["Buffer", "TypedArray", "DataView"], + data, + ); + } + + if (!options) { + throw new ERR_CRYPTO_SIGN_KEY_REQUIRED(); + } + + const key = getPrivateKey(options); + + // Options specific to RSA + const rsaPadding = getIntOption("padding", options); + const pssSaltLength = getIntOption("saltLength", options); + + // Options specific to (EC)DSA + const dsaSigEnc = getDSASignatureEncoding(options); + + if (callback === undefined) { + return Buffer.from( + cryptoImpl.signOneShot( + key, + algorithm, + data, + rsaPadding, + pssSaltLength, + dsaSigEnc, + ), + ); + } + + try { + const signature = Buffer.from( + cryptoImpl.signOneShot( + key, + algorithm, + data, + rsaPadding, + pssSaltLength, + dsaSigEnc, + ), + ); + queueMicrotask(() => callback(null, signature)); + } catch (err) { + queueMicrotask(() => callback(err)); + } +} + +export function verify( + algorithm: string | null | undefined, + data: BufferSource, + options: any, + signature: BufferSource, + callback?: VerifyCallback, +): boolean | undefined { + // Node.js allows the algorithm to be either undefined or null, in which + // case we just normalize it to undefined. + if (algorithm != null) { + validateString(algorithm, "algorithm"); + } else { + algorithm = undefined; + } + + if (!isArrayBufferView(data)) { + throw new ERR_INVALID_ARG_TYPE( + "data", + ["Buffer", "TypedArray", "DataView"], + data, + ); + } + + if (!isArrayBufferView(signature)) { + throw new ERR_INVALID_ARG_TYPE( + "signature", + ["Buffer", "TypedArray", "DataView"], + signature, + ); + } + + if (!options) { + throw new ERR_CRYPTO_SIGN_KEY_REQUIRED(); + } + + let key: CryptoKey; + if (options instanceof CryptoKey) { + key = options; + } else if (isKeyObject(options)) { + key = getKeyObjectHandle(options as KeyObject); + } else { + key = getKeyObjectHandle( + createPublicKey(options as CreateAsymmetricKeyOptions), + ); + } + if (!(key instanceof CryptoKey) && !isKeyObject(key)) { + throw new ERR_INVALID_ARG_TYPE( + "options", + ["KeyObject", "CryptoKey", "object"], + key, + ); + } + + // Options specific to RSA + const rsaPadding = getIntOption("padding", options); + const pssSaltLength = getIntOption("saltLength", options); + + // Options specific to (EC)DSA + const dsaSigEnc = getDSASignatureEncoding(options); + + if (callback === undefined) { + return cryptoImpl.verifyOneShot( + key, + algorithm, + data, + signature, + rsaPadding, + pssSaltLength, + dsaSigEnc, + ); + } + + try { + callback( + null, + cryptoImpl.verifyOneShot( + key, + algorithm, + data, + signature, + rsaPadding, + pssSaltLength, + dsaSigEnc, + ), + ); + } catch (err) { + queueMicrotask(() => callback(err)); + } + return; // explicit return is necessary to squelch typescript warning. +} diff --git a/src/compat/crypto/symmetric.ts b/src/compat/crypto/symmetric.ts new file mode 100644 index 00000000..8cb36a21 --- /dev/null +++ b/src/compat/crypto/symmetric.ts @@ -0,0 +1,131 @@ +import { Buffer } from "node:buffer"; +import { Transform } from "../stream/transform.js"; +// @ts-expect-error dependency has no declarations +import original from "crypto-browserify/index.js"; +import { secretMaterial } from "./keys.js"; +const BaseTransform = + Transform as unknown as typeof import("node:stream").Transform; +const handles = new WeakMap(); +export class Hmac extends BaseTransform { + constructor(algorithm: string, key: unknown, options?: any) { + super(options); + handles.set( + this, + original.createHmac( + algorithm, + typeof key === "string" + ? Buffer.from(key, options?.encoding) + : secretMaterial(key), + ), + ); + } + update(data: unknown, encoding?: string): this { + handles.get(this).update(data, encoding); + return this; + } + digest(encoding?: string): any { + return handles.get(this).digest(encoding); + } + override _transform(chunk: any, encoding: any, callback: any) { + try { + this.update(chunk, encoding); + callback(); + } catch (error) { + callback(error); + } + } + override _flush(callback: any) { + try { + this.push(this.digest()); + callback(); + } catch (error) { + callback(error); + } + } +} +class CipherTransform extends BaseTransform { + constructor( + decrypt: boolean, + algorithm: string, + key: unknown, + iv: unknown, + options?: any, + ) { + super(options); + handles.set( + this, + (decrypt ? original.createDecipheriv : original.createCipheriv)( + algorithm, + secretMaterial(key), + iv, + options, + ), + ); + } + update(data: unknown, inputEncoding?: string, outputEncoding?: string): any { + return handles.get(this).update(data, inputEncoding, outputEncoding); + } + final(encoding?: string): any { + return handles.get(this).final(encoding); + } + setAutoPadding(value?: boolean): this { + handles.get(this).setAutoPadding(value); + return this; + } + setAAD(data: unknown, options?: any): this { + handles.get(this).setAAD(data, options); + return this; + } + getAuthTag(): any { + return handles.get(this).getAuthTag(); + } + setAuthTag(data: unknown): this { + handles.get(this).setAuthTag(data); + return this; + } + override _transform(chunk: any, encoding: any, callback: any) { + try { + this.push(this.update(chunk, encoding)); + callback(); + } catch (error) { + callback(error); + } + } + override _flush(callback: any) { + try { + this.push(this.final()); + callback(); + } catch (error) { + callback(error); + } + } +} +export class Cipheriv extends CipherTransform { + constructor(algorithm: string, key: unknown, iv: unknown, options?: any) { + super(false, algorithm, key, iv, options); + } +} +export class Decipheriv extends CipherTransform { + constructor(algorithm: string, key: unknown, iv: unknown, options?: any) { + super(true, algorithm, key, iv, options); + } +} +export function createHmac(algorithm: string, key: unknown, options?: any) { + return new Hmac(algorithm, key, options); +} +export function createCipheriv( + algorithm: string, + key: unknown, + iv: unknown, + options?: any, +) { + return new Cipheriv(algorithm, key, iv, options); +} +export function createDecipheriv( + algorithm: string, + key: unknown, + iv: unknown, + options?: any, +) { + return new Decipheriv(algorithm, key, iv, options); +} diff --git a/src/compat/crypto/validation.ts b/src/compat/crypto/validation.ts new file mode 100644 index 00000000..47c6c31d --- /dev/null +++ b/src/compat/crypto/validation.ts @@ -0,0 +1,26 @@ +import { Buffer } from "node:buffer"; +import { ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } from "../net/errors.js"; +export function validateInteger( + value: unknown, + name: string, + min = Number.MIN_SAFE_INTEGER, + max = Number.MAX_SAFE_INTEGER, +): asserts value is number { + if (typeof value !== "number") + throw new ERR_INVALID_ARG_TYPE(name, "number", value); + if (!Number.isInteger(value)) + throw new ERR_OUT_OF_RANGE(name, "an integer", value); + if (value < min || value > max) + throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value); +} +export function bytes(value: unknown, name: string): Buffer { + if (typeof value === "string") return Buffer.from(value); + if (value instanceof ArrayBuffer) return Buffer.from(value); + if (ArrayBuffer.isView(value)) + return Buffer.from(value.buffer, value.byteOffset, value.byteLength); + throw new ERR_INVALID_ARG_TYPE( + name, + ["string", "ArrayBuffer", "Buffer", "TypedArray", "DataView"], + value, + ); +} diff --git a/src/compat/events/README.md b/src/compat/events/README.md new file mode 100644 index 00000000..ab251246 --- /dev/null +++ b/src/compat/events/README.md @@ -0,0 +1,57 @@ +# Events in the WebView profile + +This adapter targets workerd `1.20261012.1`, compatibility date `2026-10-17`, +through the cf-workers-native Vite and esbuild plugins. It implements the pinned +`events` exports for page and Dedicated Worker execution on Capacitor WebViews. +The WebView profile is an explicitly scoped target; it is not a claim of complete +Workers engine equivalence or complete `process`/`async_hooks` compatibility. + +The adapter includes EventEmitter listener ordering, mutation and removal, +listener limits, error monitoring, rejection capture, `once`, async iteration, +abort/disposal helpers and EventEmitterAsyncResource. It preserves Workers' +behavior where that differs from desktop Node: EventTarget listener introspection +returns an empty list, and the pinned EventEmitterAsyncResource `emit` returns +true even when no listener exists. Options unsupported by the pinned Workers +implementation do not acquire desktop Node behavior here. + +`process` event delivery, `emitWarning` and `nextTick` are shared with the adapter. +A listener-limit warning reaches `process.on("warning")` asynchronously, with the +original Error object. `nextTick` uses queueMicrotask as in the pinned workerd +implementation. Other process exports retain the existing dependency polyfill; +this change does not implement a Node operating-system process. + +## Profile boundaries + +- Application async functions must pass through the supplied build plugins. + Untransformed native async callbacks do not have Workers' engine context hooks. + AsyncResource propagation is covered for transformed concurrent listeners. +- Native error stacks, V8 call sites and inspection of hidden Proxy/Promise state + are host-dependent. WebKit does not implement V8's Error.captureStackTrace. + Warning delivery is supported; V8 stack inspection is not promised. +- The existing partial process and async-hooks profiles remain visible in the + repository compatibility inventory. Their missing exports are not hidden by + events surface alignment. + +## Reproduction + +Run `npm run build`, then: + +```sh +node --test demo/tests/experiments/node-compat/events-baseline.probe.mjs \ + demo/tests/experiments/node-compat/events-surface.probe.mjs \ + demo/tests/experiments/node-compat/events-contracts.probe.mjs +``` + +The same cases in `index.spec.mjs` run against the pinned workerd and through both +public build plugins in Chromium and WebKit, in page and Dedicated Worker modes. +`observations.spec.mjs` additionally covers abort-listener disposal and Workers +export/default-property behavior. Assertions cover actual behavior, not merely +export presence. Generated evidence belongs under `demo/artifacts/node-inventory`. + +The `events-native.mjs` runner uses an independently installed npm tarball, +a Capacitor shell and a local HTTPS report endpoint. It runs the same operation +cases in both execution modes on a simulator/emulator. It verifies every returned +case against workerd and records the compiled source hash and platform. Run it +with `ios ` or `android ` after running `npm run test:events:native:prepare --prefix demo`. +Then use `npm run test:events:native --prefix demo -- `. +The preparation step builds and installs a local tarball; it does not publish it. diff --git a/src/compat/events/errors.ts b/src/compat/events/errors.ts new file mode 100644 index 00000000..0f4cc6c3 --- /dev/null +++ b/src/compat/events/errors.ts @@ -0,0 +1,43 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Adapted from Deno and Node.js: +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// +// Adapted from Node.js. Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. +export { + AbortError, + ERR_INVALID_ARG_TYPE, + ERR_OUT_OF_RANGE, +} from "../net/errors.js"; +import { NodeError, NodeTypeError } from "../net/error-base.js"; +export class ERR_UNHANDLED_ERROR extends NodeError { + constructor(x: string) { + super("ERR_UNHANDLED_ERROR", `Unhandled error. (${x})`); + } +} +export class ERR_INVALID_THIS extends NodeTypeError { + constructor(x: string) { + super("ERR_INVALID_THIS", `Value of "this" must be of type ${x}`); + } +} diff --git a/src/compat/events/index.cjs b/src/compat/events/index.cjs new file mode 100644 index 00000000..7c72726b --- /dev/null +++ b/src/compat/events/index.cjs @@ -0,0 +1 @@ +module.exports = require("./index.js").default; diff --git a/src/compat/events/index.spec.mjs b/src/compat/events/index.spec.mjs new file mode 100644 index 00000000..d6a52f7b --- /dev/null +++ b/src/compat/events/index.spec.mjs @@ -0,0 +1,426 @@ +// Differential operations against the pinned Workers profile. These cases do +// not certify async_hooks, warnings/process integration or native acceptance. +export const eventCases = { + warningDelivery: async ({ process }) => { + const warnings = []; + const order = []; + const original = Object.assign(new Error("original"), { marker: true }); + const listener = function (value) { + order.push("warning"); + warnings.push({ + receiver: this === process, + original: value === original, + name: value.name, + message: value.message, + code: value.code ?? null, + detail: value.detail ?? null, + }); + }; + process.on("warning", listener); + try { + process.emitWarning(original); + process.emitWarning("text", { + type: "CustomWarning", + code: "CUSTOM", + detail: "detail", + }); + order.push("sync"); + queueMicrotask(() => order.push("microtask")); + await new Promise((resolve) => setTimeout(resolve, 0)); + const errors = []; + for (const run of [ + () => process.emitWarning(1), + () => process.emitWarning("text", 1), + () => process.emitWarning("text", "Warning", 1), + ]) { + try { + run(); + } catch (error) { + errors.push({ name: error.name, code: error.code }); + } + } + return { warnings, order, errors }; + } finally { + process.removeListener("warning", listener); + } + }, + nextTickOrdering: async ({ process }) => { + const order = []; + process.nextTick((a, b) => order.push(a + b), 1, 2); + Promise.resolve().then(() => order.push("promise")); + queueMicrotask(() => order.push("microtask")); + order.push("sync"); + await new Promise((resolve) => setTimeout(resolve, 0)); + return order; + }, + warnings: async ({ events: e, process }) => { + const warnings = []; + const listener = (value) => + warnings.push({ + name: value.name, + type: String(value.type), + count: value.count, + }); + process.on("warning", listener); + const logs = []; + const oldLog = console.log; + const oldWarn = console.warn; + const capture = (...args) => + logs.push( + args.map((value) => + typeof value === "string" + ? value + : { + name: value.name, + message: value.message, + type: String(value.type), + count: value.count, + }, + ), + ); + console.log = capture; + console.warn = capture; + try { + const emitter = new e.EventEmitter(); + emitter.setMaxListeners(1); + emitter.on("item", () => {}); + emitter.on("item", () => {}); + emitter.on("item", () => {}); + await new Promise((resolve) => setTimeout(resolve, 0)); + return { logs, warnings, count: emitter.listenerCount("item") }; + } finally { + console.log = oldLog; + console.warn = oldWarn; + process.removeListener("warning", listener); + } + }, + listeners: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const calls = []; + function listener(...args) { + calls.push([this === emitter, ...args]); + } + const symbol = Symbol("item"); + const chain = [ + emitter.on(symbol, listener), + emitter.addListener(symbol, listener), + emitter.prependListener(symbol, listener), + emitter.once("once", listener), + emitter.prependOnceListener("once", listener), + ].every((x) => x === emitter); + const before = [ + emitter.listenerCount(symbol), + e.listenerCount(emitter, symbol), + emitter.listeners("once").every((x) => x === listener), + emitter.rawListeners("once").every((x) => x.listener === listener), + emitter.eventNames().map(String), + ]; + const emitted = [ + emitter.emit(symbol, 1), + emitter.emit("once", 2), + emitter.emit("once", 3), + ]; + emitter.off(symbol, listener); + emitter.removeListener(symbol, listener); + const after = emitter.listenerCount(symbol); + const removed = emitter.removeAllListeners() === emitter; + return { + chain, + before, + emitted, + calls, + after, + removed, + names: emitter.eventNames(), + }; + }, + listenerMutation: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const log = []; + const second = () => log.push("second"); + emitter.on("newListener", (name) => log.push(`add:${String(name)}`)); + emitter.on("removeListener", (name) => log.push(`remove:${String(name)}`)); + emitter.on("item", () => { + log.push("first"); + emitter.removeListener("item", second); + }); + emitter.on("item", second); + emitter.emit("item"); + emitter.emit("item"); + emitter.removeAllListeners("item"); + emitter.removeAllListeners(); + return { log, count: emitter.eventNames().length }; + }, + defaults: async ({ events: e }) => { + const original = e.default.defaultMaxListeners; + const capture = e.default.captureRejections; + try { + e.setMaxListeners(7); + const a = new e.EventEmitter(); + const b = new e.EventEmitter(); + const inherited = [a.getMaxListeners(), e.defaultMaxListeners]; + e.setMaxListeners(3, a, b); + const configured = [ + e.getMaxListeners(a), + b.getMaxListeners(), + a.setMaxListeners(0) === a, + a.getMaxListeners(), + ]; + const target = new EventTarget(); + e.setMaxListeners(2, target); + e.default.captureRejections = true; + return { + inherited, + configured, + targetMax: e.getMaxListeners(target), + targetListeners: e.getEventListeners(target, "x"), + capture: [e.captureRejections, e.default.captureRejections], + domains: e.usingDomains, + rejectionKey: Symbol.keyFor(e.captureRejectionSymbol), + }; + } finally { + e.default.defaultMaxListeners = original; + e.default.captureRejections = capture; + } + }, + invalidInputs: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const errors = []; + const operations = [ + () => emitter.on("x", 1), + () => emitter.once("x", null), + () => emitter.prependListener("x", false), + () => emitter.prependOnceListener("x", {}), + () => emitter.removeListener("x", 4), + () => emitter.setMaxListeners(-1), + () => e.setMaxListeners(NaN), + () => { + e.default.defaultMaxListeners = -1; + }, + () => { + e.default.captureRejections = 1; + }, + () => new e.EventEmitter({ captureRejections: "yes" }), + () => e.getEventListeners({}, "x"), + () => e.setMaxListeners(1, {}), + () => e.addAbortListener(undefined, () => {}), + () => e.addAbortListener(new AbortController().signal, 1), + () => e.once(emitter, "x", 1), + () => e.on(emitter, "x", { signal: 1 }), + ]; + for (const run of operations) { + try { + await run(); + errors.push(null); + } catch (error) { + errors.push({ + name: error.name, + code: error.code, + message: error.message, + }); + } + } + return errors; + }, + errorMonitor: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const log = []; + const error = new Error("failure"); + emitter.on(e.errorMonitor, (value) => + log.push(["monitor", value === error]), + ); + let thrown; + try { + emitter.emit("error", error); + } catch (value) { + thrown = value === error; + } + emitter.on("error", (value) => log.push(["handler", value === error])); + const emitted = emitter.emit("error", error); + return { log, thrown, emitted }; + }, + once: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const first = e.once(emitter, "item"); + emitter.emit("item", 1, 2); + const value = await first; + const second = e.once(emitter, "item"); + emitter.emit("error", new Error("rejected")); + let error; + try { + await second; + } catch (value) { + error = value.message; + } + const target = new EventTarget(); + const third = e.once(target, "item"); + target.dispatchEvent(new Event("item")); + const targetValue = (await third).map((value) => value.type); + return { value, error, targetValue, listeners: emitter.eventNames() }; + }, + onceAbort: async ({ events: e }) => { + const results = []; + for (const alreadyAborted of [true, false]) { + const emitter = new e.EventEmitter(); + const controller = new AbortController(); + if (alreadyAborted) controller.abort("reason"); + const promise = e.once(emitter, "item", { signal: controller.signal }); + if (!alreadyAborted) controller.abort("reason"); + try { + await promise; + } catch (error) { + results.push({ + name: error.name, + code: error.code, + cause: error.cause ?? null, + listeners: emitter.eventNames(), + }); + } + } + return results; + }, + iteratorQueue: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const iterator = e.on(emitter, "item"); + const identity = iterator[Symbol.asyncIterator]() === iterator; + emitter.emit("item", 1); + emitter.emit("item", 2, 3); + const values = [await iterator.next(), await iterator.next()]; + const pending = [iterator.next(), iterator.next()]; + const returned = await iterator.return(); + return { + identity, + values, + returned, + pending: await Promise.all(pending), + next: await iterator.next(), + listeners: emitter.eventNames(), + }; + }, + iteratorError: async ({ events: e }) => { + const result = []; + for (const pending of [true, false]) { + const emitter = new e.EventEmitter(); + const iterator = e.on(emitter, "item"); + const next = pending ? iterator.next() : null; + emitter.emit("error", new Error("failure")); + let message; + try { + await (next ?? iterator.next()); + } catch (error) { + message = error.message; + } + result.push({ + message, + next: await iterator.next(), + listeners: emitter.eventNames(), + }); + } + return result; + }, + iteratorThrow: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const iterator = e.on(emitter, "item"); + let invalid; + try { + iterator.throw("bad"); + } catch (error) { + invalid = error.code; + } + const returned = iterator.throw(new Error("thrown")); + let message; + try { + await iterator.next(); + } catch (error) { + message = error.message; + } + await iterator.return(); + return { invalid, returned, message, listeners: emitter.eventNames() }; + }, + iteratorAbort: async ({ events: e }) => { + const emitter = new e.EventEmitter(); + const controller = new AbortController(); + const iterator = e.on(emitter, "item", { signal: controller.signal }); + const pending = iterator.next(); + controller.abort(); + let code; + try { + await pending; + } catch (error) { + code = error.code; + } + let already; + try { + e.on(emitter, "item", { signal: controller.signal }); + } catch (error) { + already = error.code; + } + return { + code, + already, + done: await iterator.next(), + listeners: emitter.eventNames(), + }; + }, + rejectionHook: async ({ events: e }) => { + const emitter = new e.EventEmitter({ captureRejections: true }); + const captured = new Promise((resolve) => { + emitter[e.captureRejectionSymbol] = function (error, event, ...args) { + resolve({ + receiver: this === emitter, + message: error.message, + event, + args, + }); + }; + }); + emitter.on("item", async () => { + throw new Error("rejection"); + }); + emitter.emit("item", 1, 2); + return captured; + }, + resourceConcurrency: async ({ events: e, AsyncLocalStorage }) => { + const als = new AsyncLocalStorage(); + const resources = ["a", "b"].map((value) => + als.run(value, () => new e.EventEmitterAsyncResource()), + ); + const completions = resources.map( + (emitter, i) => + new Promise((resolve) => { + emitter.on("item", async () => { + const before = als.getStore(); + await Promise.resolve(); + const afterPromise = als.getStore(); + await new Promise((done) => setTimeout(done, i)); + resolve([before, afterPromise, als.getStore()]); + }); + }), + ); + als.run("caller", () => { + for (const resource of resources) resource.emit("item"); + }); + return { + values: await Promise.all(completions), + restored: als.getStore() ?? null, + }; + }, + resource: async ({ events: e, AsyncLocalStorage }) => { + const als = new AsyncLocalStorage(); + const emitter = als.run("created", () => new e.EventEmitterAsyncResource()); + const seen = []; + emitter.on("item", function (value) { + seen.push([als.getStore(), this === emitter, value]); + }); + const emitted = als.run("caller", () => emitter.emit("item", 4)); + return { + seen, + emitted, + empty: emitter.emit("absent"), + owner: emitter.asyncResource.eventEmitter === emitter, + id: emitter.asyncResource.asyncId(), + trigger: emitter.asyncResource.triggerAsyncId(), + restored: als.getStore() ?? null, + }; + }, +}; diff --git a/src/compat/events/index.ts b/src/compat/events/index.ts new file mode 100644 index 00000000..0fa29891 --- /dev/null +++ b/src/compat/events/index.ts @@ -0,0 +1,1049 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Adapted from Deno and Node.js: +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// +// Adapted from Node.js. Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. +/* eslint-disable */ +// Workers events profile for the transformed WebView execution target. +// Source: cloudflare/workerd@5358e3d337336eaf696a48bc1563d808b10feba5 +// src/node/internal/events.ts. Adaptations: local validators/errors, host +// process/async_hooks/util dependencies, spliceOne, pinned process-v2 flag. +// See README.md for the supported execution profile and engine boundaries. + +import { + AbortError, + ERR_INVALID_ARG_TYPE, + ERR_INVALID_THIS, + ERR_OUT_OF_RANGE, + ERR_UNHANDLED_ERROR, +} from "./errors.js"; +import type { + EventEmitterAsyncResource as _EventEmitterAsyncResource, + EventEmitter as _EventEmitter, +} from "node:events"; +import { + validateAbortSignal, + validateBoolean, + validateFunction, + validateObject, +} from "../net/validators.js"; +function spliceOne(list: unknown[], index: number) { + for (; index + 1 < list.length; index++) list[index] = list[index + 1]; + list.pop(); +} +import { nextTick, emitWarning } from "../process/index.js"; +import { default as async_hooks } from "node:async_hooks"; +const { AsyncResource } = async_hooks; + +import { inspect } from "node:util"; + +const enableNodejsProcessV2 = true; + +const kRejection = Symbol.for("nodejs.rejection"); +const kCapture = Symbol("kCapture"); +const kErrorMonitor = Symbol("events.errorMonitor"); +const kMaxEventTargetListeners = Symbol("events.maxEventTargetListeners"); +const kMaxEventTargetListenersWarned = Symbol( + "events.maxEventTargetListenersWarned", +); + +export interface EventEmitterOptions { + captureRejections?: boolean; +} + +export type EventName = string | symbol | number; +export type EventCallback = ((...args: any[]) => unknown) & { + listener?: EventCallback; +}; +// Upstream ambient declaration removed for Babel parsing; runtime unchanged. +interface EventEmitter extends _EventEmitter { + _events: Record | undefined; + _eventsCount: number; +} + +type AsyncResource = typeof AsyncResource; + +declare var EventTarget: Function; + +export function EventEmitter( + this: EventEmitter, + opts?: EventEmitterOptions, +): EventEmitter { + EventEmitter.init.call(this, opts); + return this; +} + +class EventEmitterReferencingAsyncResource extends AsyncResource { + #eventEmitter: EventEmitter; + constructor(emitter: EventEmitter) { + super(""); + this.#eventEmitter = emitter; + } + + get eventEmitter() { + if (this.#eventEmitter === undefined) + throw new ERR_INVALID_THIS("EventEmitterReferencingAsyncResource"); + return this.#eventEmitter; + } +} + +const EventEmitterConstructor = EventEmitter as unknown as typeof _EventEmitter; + +export class EventEmitterAsyncResource + extends EventEmitterConstructor + implements _EventEmitterAsyncResource +{ + #asyncResource: EventEmitterReferencingAsyncResource; + + constructor(options?: EventEmitterOptions) { + super(options); + this.#asyncResource = new EventEmitterReferencingAsyncResource( + this as unknown as EventEmitter, + ); + } + + // @ts-expect-error TS2416 Not assignable to base type + get asyncResource(): AsyncResource { + if (this.#asyncResource === undefined) + throw new ERR_INVALID_THIS("EventEmitterAsyncResource"); + // @ts-expect-error TS2741 Prototype is missing from type. + return this.#asyncResource; + } + + override emit(event: string | symbol, ...args: any[]): boolean { + if (this.#asyncResource === undefined) + throw new ERR_INVALID_THIS("EventEmitterAsyncResource"); + args.unshift(super.emit, this, event); + Reflect.apply( + this.#asyncResource.runInAsyncScope, + this.#asyncResource, + args, + ); + return true; + } +} + +export function addAbortListener( + signal: AbortSignal | undefined, + listener: any, +) { + if (signal === undefined) { + throw new ERR_INVALID_ARG_TYPE("signal", "AbortSignal", signal); + } + validateAbortSignal(signal, "signal"); + validateFunction(listener, "listener"); + + let removeEventListener: Function; + if (signal.aborted) { + queueMicrotask(() => listener()); + } else { + signal.addEventListener("abort", listener, { once: true }); + removeEventListener = () => { + signal.removeEventListener("abort", listener); + }; + } + return { + __proto__: null, + [Symbol.dispose]() { + removeEventListener?.(); + }, + }; +} + +export default EventEmitter; + +EventEmitter.on = on; +EventEmitter.once = once; +EventEmitter.getEventListeners = getEventListeners; +EventEmitter.getMaxListeners = _getMaxListeners; +EventEmitter.setMaxListeners = setMaxListeners; +EventEmitter.listenerCount = listenerCount; +EventEmitter.EventEmitter = EventEmitter; +EventEmitter.usingDomains = false; +EventEmitter.captureRejectionSymbol = kRejection; +EventEmitter.errorMonitor = kErrorMonitor; +EventEmitter.EventEmitterAsyncResource = EventEmitterAsyncResource; + +export const captureRejectionSymbol = EventEmitter.captureRejectionSymbol; +export const captureRejections = false; +export const errorMonitor = EventEmitter.errorMonitor; +export const getMaxListeners = _getMaxListeners; +export const usingDomains = EventEmitter.usingDomains; +export let defaultMaxListeners = 10; + +Object.defineProperties(EventEmitter, { + captureRejections: { + get(this: EventEmitter) { + return EventEmitter.prototype[kCapture]; + }, + set(this: EventEmitter, value: unknown): void { + validateBoolean(value, "EventEmitter.captureRejections"); + + EventEmitter.prototype[kCapture] = value; + }, + enumerable: true, + }, + defaultMaxListeners: { + enumerable: true, + get: function (this: EventEmitter): number { + return defaultMaxListeners; + }, + set: function (this: EventEmitter, arg: unknown): void { + if (typeof arg !== "number" || arg < 0 || Number.isNaN(arg)) { + throw new ERR_OUT_OF_RANGE( + "defaultMaxListeners", + "a non-negative number", + arg, + ); + } + defaultMaxListeners = arg; + }, + }, + kMaxEventTargetListeners: { + value: kMaxEventTargetListeners, + enumerable: false, + configurable: false, + writable: false, + }, + kMaxEventTargetListenersWarned: { + value: kMaxEventTargetListenersWarned, + enumerable: false, + configurable: false, + writable: false, + }, +}); + +// The default for captureRejections is false +Object.defineProperty(EventEmitter.prototype, kCapture, { + value: false, + writable: true, + enumerable: false, +}); + +EventEmitter.init = function (this: EventEmitter, opts?: EventEmitterOptions) { + if ( + this._events === undefined || + this._events === Object.getPrototypeOf(this)._events + ) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + (this as any)._maxListeners ??= undefined; + (this as any).domain = null; + + if (opts?.captureRejections) { + validateBoolean(opts.captureRejections, "options.captureRejections"); + (this as any)[kCapture] = Boolean(opts.captureRejections); + } else { + // Assigning the kCapture property directly saves an expensive + // prototype lookup in a very sensitive hot path. + (this as any)[kCapture] = EventEmitter.prototype[kCapture]; + } +}; + +export function setMaxListeners( + n = defaultMaxListeners, + ...eventTargets: any[] +) { + if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { + throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); + } + if (eventTargets.length === 0) { + defaultMaxListeners = n; + } else { + for (let i = 0; i < eventTargets.length; i++) { + const target = eventTargets[i]; + if (target instanceof EventTarget) { + (target as any)[kMaxEventTargetListeners] = n; + (target as any)[kMaxEventTargetListenersWarned] = false; + } else if (typeof target.setMaxListeners === "function") { + target.setMaxListeners(n); + } else { + throw new ERR_INVALID_ARG_TYPE( + "eventTargets", + ["EventEmitter", "EventTarget"], + target, + ); + } + } + } +} + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._eventsCount = 0; +EventEmitter.prototype._maxListeners = undefined; +EventEmitter.addAbortListener = addAbortListener; + +function addCatch( + that: any, + promise: Promise, + type: string | symbol, + args: any[], +) { + if (!that[kCapture]) { + return; + } + + // Handle Promises/A+ spec, then could be a getter + // that throws on second use. + try { + const then = promise.then; + + if (typeof then === "function") { + then.call(promise, undefined, function (err) { + // The callback is called with nextTick to avoid a follow-up + // rejection from this promise. + nextTick(emitUnhandledRejectionOrErr, that, err, type, args); + }); + } + } catch (err) { + that.emit("error", err); + } +} + +function emitUnhandledRejectionOrErr( + ee: any, + err: any, + type: string | symbol, + args: any[], +) { + if (typeof ee[kRejection] === "function") { + ee[kRejection](err, type, ...args); + } else { + // We have to disable the capture rejections mechanism, otherwise + // we might end up in an infinite loop. + const prev = ee[kCapture]; + + // If the error handler throws, it is not catchable and it + // will end up in 'uncaughtException'. We restore the previous + // value of kCapture in case the uncaughtException is present + // and the exception is handled. + try { + ee[kCapture] = false; + ee.emit("error", err); + } finally { + ee[kCapture] = prev; + } + } +} + +EventEmitter.prototype.setMaxListeners = function setMaxListeners(n: number) { + if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { + throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); + } + this._maxListeners = n; + return this; +}; + +function _getMaxListeners(that: any) { + if (that._maxListeners === undefined) { + return (EventEmitter as any).defaultMaxListeners; + } + return that._maxListeners; +} + +EventEmitter.prototype.getMaxListeners = function getMaxListeners( + this: EventEmitter, +): number { + return _getMaxListeners(this); +}; + +EventEmitter.prototype.emit = function emit( + this: EventEmitter, + type: string | symbol, + ...args: any[] +): boolean { + let doError = type === "error"; + + const events = this._events; + if (events !== undefined) { + if (doError && events[kErrorMonitor] !== undefined) { + this.emit(kErrorMonitor, ...args); + } + doError = doError && events.error === undefined; + } else if (!doError) { + return false; + } + + // If there is no 'error' event listener then throw. + if (doError) { + let er; + if (args.length > 0) { + er = args[0]; + } + if (er instanceof Error) { + try { + const capture = {}; + (Error as any).captureStackTrace(capture, EventEmitter.prototype.emit); + } catch { + // pass + } + + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event + } + + let stringifiedEr; + try { + stringifiedEr = inspect(er); + } catch { + stringifiedEr = er; + } + + // At least give some kind of context to the user + const err = new ERR_UNHANDLED_ERROR(stringifiedEr); + (err as any).context = er; + throw err; // Unhandled 'error' event + } + + const handler = events?.[type]; + + if (handler === undefined) { + return false; + } + + if (typeof handler === "function") { + const result = (handler as Function).apply(this, args); + + // We check if result is undefined first because that + // is the most common case so we do not pay any perf + // penalty + if (result !== undefined && result !== null) { + addCatch(this, result, type, args); + } + } else { + const len = handler.length; + const listeners = arrayClone(handler); + for (let i = 0; i < len; ++i) { + const result = listeners[i].apply(this, args); + + // We check if result is undefined first because that + // is the most common case so we do not pay any perf + // penalty. + // This code is duplicated because extracting it away + // would make it non-inlineable. + if (result !== undefined && result !== null) { + addCatch(this, result, type, args); + } + } + } + + return true; +}; + +function _addListener( + target: any, + type: string | symbol, + listener: unknown, + prepend: boolean, +) { + let m; + let events; + let existing; + + validateFunction(listener, "listener"); + + events = target._events; + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit("newListener", type, (listener as any).listener ?? listener); + + // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + events = target._events; + } + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === "function") { + // Adding the second element, need to change to array. + existing = events[type] = prepend + ? [listener, existing] + : [existing, listener]; + // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + + // Check for listener leak + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + console.log( + "Possible EventEmitter memory leak detected. " + + `${existing.length} ${String(type)} listeners ` + + `added to an EventEmitter. Use ` + + "emitter.setMaxListeners() to increase limit", + ); + const w: EventEmitterError = Object.assign( + new Error( + "Possible EventEmitter memory leak detected. " + + `${existing.length} ${String(type)} listeners ` + + `added to ${inspect(target, { depth: -1 })}. Use ` + + "emitter.setMaxListeners() to increase limit", + ), + { + name: "MaxListenersExceededWarning", + emitter: target, + type: type, + count: existing.length, + }, + ); + // Only the newer process version compat adds process.emitWarning support. + if (enableNodejsProcessV2) emitWarning(w); + } + } + + return target; +} + +interface EventEmitterError extends Error { + name: string; + emitter: unknown; + type: string | symbol; + count: number; +} + +EventEmitter.prototype.addListener = function addListener( + this: EventEmitter, + type: string | symbol, + listener: unknown, +) { + return _addListener(this, type, listener, false); +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.prependListener = function prependListener( + type: string | symbol, + listener: unknown, +) { + return _addListener(this, type, listener, true); +}; + +function onceWrapper(this: any) { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) { + return this.listener.call(this.target); + } + return this.listener.apply(this.target, arguments); + } +} + +function _onceWrap(target: any, type: string | symbol, listener: unknown) { + const state = { fired: false, wrapFn: undefined, target, type, listener }; + const wrapped = onceWrapper.bind(state); + (wrapped as any).listener = listener; + (state as any).wrapFn = wrapped; + return wrapped; +} + +EventEmitter.prototype.once = function once( + type: string | symbol, + listener: unknown, +) { + validateFunction(listener, "listener"); + + this.on(type, _onceWrap(this, type, listener)); + return this; +}; + +EventEmitter.prototype.prependOnceListener = function prependOnceListener( + type: string | symbol, + listener: unknown, +) { + validateFunction(listener, "listener"); + + this.prependListener(type, _onceWrap(this, type, listener)); + return this; +}; + +EventEmitter.prototype.removeListener = function removeListener( + type: string | symbol, + listener: unknown, +) { + validateFunction(listener, "listener"); + + const events = this._events; + if (events === undefined) { + return this; + } + + const list = events[type] as EventCallback | EventCallback[] | undefined; + if (list === undefined) { + return this; + } + + if (list === listener || ("listener" in list && list.listener === listener)) { + if (--this._eventsCount === 0) { + this._events = Object.create(null); + } else { + delete events[type]; + if (events.removeListener) { + this.emit("removeListener", type, list.listener || listener); + } + } + } else if (typeof list !== "function") { + let position = -1; + + for (let i = list.length - 1; i >= 0; i--) { + if ( + list[i] === listener || + (list[i] as EventCallback).listener === listener + ) { + position = i; + break; + } + } + + if (position < 0) { + return this; + } + + if (position === 0) { + list.shift(); + } else { + spliceOne(list, position); + } + + if (list.length === 1) { + events[type] = list.at(0) as unknown as EventCallback[]; + } + + if (events.removeListener !== undefined) { + this.emit("removeListener", type, listener); + } + } + + return this; +}; + +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + +EventEmitter.prototype.removeAllListeners = function removeAllListeners( + type: string | symbol, +) { + const events = this._events; + if (events === undefined) { + return this; + } + + // Not listening for removeListener, no need to emit + if (events.removeListener === undefined) { + if (arguments.length === 0) { + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) { + this._events = Object.create(null); + } else { + delete events[type]; + } + } + return this; + } + + // Emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (const key of Reflect.ownKeys(events)) { + if (key === "removeListener") continue; + this.removeAllListeners(key); + } + this.removeAllListeners("removeListener"); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } + + const listeners = events[type]; + + if (typeof listeners === "function") { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (let i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i] as EventListener); + } + } + + return this; +}; + +function _listeners(target: any, type: string | symbol, unwrap: boolean) { + const events = target._events; + + if (events === undefined) { + return []; + } + + const evlistener = events[type]; + if (evlistener === undefined) { + return []; + } + + if (typeof evlistener === "function") { + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + } + + return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener); +} + +EventEmitter.prototype.listeners = function listeners(type: string | symbol) { + return _listeners(this, type, true); +}; + +EventEmitter.prototype.rawListeners = function rawListeners( + type: string | symbol, +) { + return _listeners(this, type, false); +}; + +const _listenerCount = function listenerCount( + this: any, + type: string | symbol, +) { + const events = this._events; + + if (events !== undefined) { + const evlistener = events[type]; + + if (typeof evlistener === "function") { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; + } + } + + return 0; +}; + +EventEmitter.prototype.listenerCount = _listenerCount; + +export function listenerCount(emitter: any, type: string | symbol) { + if (typeof emitter.listenerCount === "function") { + return emitter.listenerCount(type); + } + return _listenerCount.call(emitter, type); +} + +EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? Reflect.ownKeys(this._events || {}) : []; +}; + +function arrayClone(arr: any[]) { + // At least since V8 8.3, this implementation is faster than the previous + // which always used a simple for-loop + switch (arr.length) { + case 2: + return [arr[0], arr[1]]; + case 3: + return [arr[0], arr[1], arr[2]]; + case 4: + return [arr[0], arr[1], arr[2], arr[3]]; + case 5: + return [arr[0], arr[1], arr[2], arr[3], arr[4]]; + case 6: + return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]]; + } + return arr.slice(); +} + +function unwrapListeners(arr: any[]) { + const ret = arrayClone(arr); + for (let i = 0; i < ret.length; ++i) { + const orig = ret[i].listener; + if (typeof orig === "function") { + ret[i] = orig; + } + } + return ret; +} + +export function getEventListeners(emitterOrTarget: any, type: string | symbol) { + // First check if EventEmitter + if (typeof emitterOrTarget.listeners === "function") { + return emitterOrTarget.listeners(type); + } + if (emitterOrTarget instanceof EventTarget) { + // Workers does not implement the ability to get the event listeners on an + // EventTarget the way that Node.js does. We simply return empty here. + return []; + } + throw new ERR_INVALID_ARG_TYPE( + "emitter", + ["EventEmitter", "EventTarget"], + emitterOrTarget, + ); +} + +export interface OnceOptions { + signal?: AbortSignal; +} + +export async function once( + emitter: any, + name: string | symbol, + options: OnceOptions = {}, +) { + validateObject(options, "options"); + const { signal } = options; + validateAbortSignal(signal, "options.signal"); + if (signal?.aborted) { + throw new AbortError(undefined, { cause: signal.reason }); + } + return new Promise((resolve, reject) => { + const errorListener = (err: any) => { + emitter.removeListener(name, resolver); + if (signal != null) { + eventTargetAgnosticRemoveListener(signal, "abort", abortListener); + } + reject(err); + }; + const resolver = (...args: any[]) => { + if (typeof emitter.removeListener === "function") { + emitter.removeListener("error", errorListener); + } + if (signal != null) { + eventTargetAgnosticRemoveListener(signal, "abort", abortListener); + } + resolve(args); + }; + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== "error" && typeof emitter.once === "function") { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we listen to `error` events only on EventEmitters. + emitter.once("error", errorListener); + } + function abortListener() { + eventTargetAgnosticRemoveListener(emitter, name, resolver); + eventTargetAgnosticRemoveListener(emitter, "error", errorListener); + reject(new AbortError()); + } + if (signal != null) { + eventTargetAgnosticAddListener(signal, "abort", abortListener, { + once: true, + }); + } + }); +} + +import { AsyncIteratorPrototype } from "./intrinsics.js"; + +function createIterResult(value: any, done: boolean) { + return { value, done }; +} + +function eventTargetAgnosticRemoveListener( + emitter: any, + name: string | symbol, + listener: unknown, + flags: unknown = undefined, +) { + if (typeof emitter.removeListener === "function") { + emitter.removeListener(name, listener); + } else if (typeof emitter.removeEventListener === "function") { + emitter.removeEventListener(name, listener, flags); + } else { + throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); + } +} + +interface AddListenerFlags { + once?: boolean; +} + +function eventTargetAgnosticAddListener( + emitter: any, + name: string | symbol, + listener: unknown, + flags: AddListenerFlags = {}, +) { + if (typeof emitter.on === "function") { + if (flags?.once) { + emitter.once(name, listener); + } else { + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === "function") { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we do not listen to `error` events here. + emitter.addEventListener( + name, + (arg: unknown) => { + (listener as any)(arg); + }, + flags, + ); + } else { + throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); + } +} + +interface OnOptions { + signal?: AbortSignal; +} + +export function on( + emitter: any, + event: string | symbol, + options: OnOptions = {}, +) { + const signal = options?.signal; + validateAbortSignal(signal, "options.signal"); + if (signal?.aborted) { + throw new AbortError(); + } + + const unconsumedEvents: any[] = []; + const unconsumedPromises: any[] = []; + let error: any = null; + let finished = false; + + const iterator = Object.setPrototypeOf( + { + next() { + // First, we consume all unread events + const value = unconsumedEvents.shift(); + if (value) { + return Promise.resolve(createIterResult(value, false)); + } + + // Then we error, if an error happened + // This happens one time if at all, because after 'error' + // we stop listening + if (error) { + const p = Promise.reject(error); + // Only the first element errors + error = null; + return p; + } + + // If the iterator is finished, resolve to done + if (finished) { + return Promise.resolve(createIterResult(undefined, true)); + } + + // Wait until an event happens + return new Promise(function (resolve, reject) { + unconsumedPromises.push({ resolve, reject }); + }); + }, + + return() { + eventTargetAgnosticRemoveListener(emitter, event, eventHandler); + eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); + + if (signal) { + eventTargetAgnosticRemoveListener(signal, "abort", abortListener, { + once: true, + }); + } + + finished = true; + + for (const promise of unconsumedPromises) { + promise.resolve(createIterResult(undefined, true)); + } + + return Promise.resolve(createIterResult(undefined, true)); + }, + + throw(err: any) { + if (!err || !(err instanceof Error)) { + throw new ERR_INVALID_ARG_TYPE( + "EventEmitter.AsyncIterator", + "Error", + err, + ); + } + error = err; + eventTargetAgnosticRemoveListener(emitter, event, eventHandler); + eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); + }, + + [Symbol.asyncIterator]() { + return this; + }, + }, + AsyncIteratorPrototype, + ); + + eventTargetAgnosticAddListener(emitter, event, eventHandler); + if (event !== "error" && typeof emitter.on === "function") { + emitter.on("error", errorHandler); + } + + if (signal) { + eventTargetAgnosticAddListener(signal, "abort", abortListener, { + once: true, + }); + } + + return iterator; + + function abortListener() { + errorHandler(new AbortError()); + } + + function eventHandler(...args: any[]) { + const promise = unconsumedPromises.shift(); + if (promise) { + promise.resolve(createIterResult(args, false)); + } else { + unconsumedEvents.push(args); + } + } + + function errorHandler(err: any) { + finished = true; + + const toError = unconsumedPromises.shift(); + + if (toError) { + toError.reject(err); + } else { + // The next time we call next() + error = err; + } + + iterator.return(); + } +} diff --git a/src/compat/events/intrinsics.ts b/src/compat/events/intrinsics.ts new file mode 100644 index 00000000..47ff2482 --- /dev/null +++ b/src/compat/events/intrinsics.ts @@ -0,0 +1,4 @@ +// Native intrinsic discovery must survive the ordinary async lowering pipeline. +export const AsyncIteratorPrototype = Object.getPrototypeOf( + Object.getPrototypeOf(async function* () {}).prototype, +); diff --git a/src/compat/events/observations.spec.mjs b/src/compat/events/observations.spec.mjs new file mode 100644 index 00000000..300d0c68 --- /dev/null +++ b/src/compat/events/observations.spec.mjs @@ -0,0 +1,167 @@ +// Shared feasibility observations, not whole-module acceptance. +export async function observeEvents(events, AsyncLocalStorage) { + const emitter = new events.EventEmitter(); + const handler = () => {}; + emitter.on("item", handler); + const listed = events.getEventListeners(emitter, "item"); + listed.length = 0; + const target = new EventTarget(); + target.addEventListener("item", handler); + const targetListeners = events.getEventListeners(target, "item").length; + events.setMaxListeners(2, target); + const targetMax = events.getMaxListeners(target); + const aborted = new AbortController(); + aborted.abort("cause"); + const order = []; + const disposed = events.addAbortListener(aborted.signal, () => + order.push("callback"), + ); + disposed[Symbol.dispose](); + order.push("sync"); + await Promise.resolve(); + const pending = new AbortController(); + let pendingCalls = 0; + const disposable = events.addAbortListener( + pending.signal, + () => pendingCalls++, + ); + disposable[Symbol.dispose](); + pending.abort(); + const stopped = new AbortController(); + let stoppedCalls = 0; + stopped.signal.addEventListener("abort", (event) => + event.stopImmediatePropagation(), + ); + events.addAbortListener(stopped.signal, () => stoppedCalls++); + stopped.abort(); + const als = new AsyncLocalStorage(); + const resource = als.run( + "creation", + () => new events.EventEmitterAsyncResource(), + ); + let store; + resource.on("item", () => { + store = als.getStore(); + }); + const emitResult = als.run("dispatch", () => resource.emit("item")); + const emptyEmitResult = resource.emit("absent"); + const iterator = events.on(emitter, "data"); + emitter.emit("data", 1, 2); + const first = await iterator.next(); + await iterator.return(); + const iteratorCleaned = + emitter.listenerCount("data") === 0 && emitter.listenerCount("error") === 0; + const captureBefore = events.captureRejections; + events.default.captureRejections = true; + const captureAfter = events.captureRejections; + const captureDefault = events.default.captureRejections; + events.default.captureRejections = false; + const sequence = []; + const ordered = new events.EventEmitter(); + const late = () => sequence.push("late"); + ordered.on("tick", () => { + sequence.push("first"); + ordered.removeListener("tick", late); + }); + ordered.on("tick", late); + ordered.prependOnceListener("tick", () => sequence.push("once")); + ordered.emit("tick"); + ordered.emit("tick"); + const promiseEmitter = new events.EventEmitter(); + const pendingOnce = events.once(promiseEmitter, "ready"); + promiseEmitter.emit("ready", 3, 4); + const onceValue = await pendingOnce; + const onceCleaned = + promiseEmitter.listenerCount("ready") === 0 && + promiseEmitter.listenerCount("error") === 0; + const abort = new AbortController(); + const abortOnce = events.once(promiseEmitter, "ready", { + signal: abort.signal, + }); + abort.abort("cancel"); + let abortError; + try { + await abortOnce; + } catch (error) { + abortError = { + name: error.name, + code: error.code, + cause: error.cause ?? null, + }; + } + const abortCleaned = + promiseEmitter.listenerCount("ready") === 0 && + promiseEmitter.listenerCount("error") === 0; + const rejectionEmitter = new events.EventEmitter({ captureRejections: true }); + const captured = new Promise((resolve) => + rejectionEmitter.once("error", (error) => resolve(error.message)), + ); + rejectionEmitter.on("reject", async () => { + throw new Error("captured"); + }); + rejectionEmitter.emit("reject"); + const capturedMessage = await captured; + const errors = []; + for (const operation of [ + () => emitter.on("x", 1), + () => events.setMaxListeners(-1), + () => emitter.emit("error", "failure"), + ]) { + try { + operation(); + } catch (error) { + errors.push({ name: error.name, code: error.code }); + } + } + return { + sequence, + onceValue, + onceCleaned, + abortError, + abortCleaned, + capturedMessage, + errors, + emitterListeners: emitter.listenerCount("item"), + targetListeners, + targetMax, + order, + pendingCalls, + stoppedCalls, + store, + emitResult, + emptyEmitResult, + first, + iteratorCleaned, + captureBefore, + captureAfter, + captureDefault, + }; +} + +export const expectedEvents = { + sequence: ["once", "first", "late", "first"], + onceValue: [3, 4], + onceCleaned: true, + abortError: { name: "AbortError", code: "ABORT_ERR", cause: null }, + abortCleaned: true, + capturedMessage: "captured", + errors: [ + { name: "TypeError", code: "ERR_INVALID_ARG_TYPE" }, + { name: "RangeError", code: "ERR_OUT_OF_RANGE" }, + { name: "Error", code: "ERR_UNHANDLED_ERROR" }, + ], + emitterListeners: 1, + targetListeners: 0, + targetMax: 10, + order: ["sync", "callback"], + pendingCalls: 0, + stoppedCalls: 0, + store: "creation", + emitResult: true, + emptyEmitResult: true, + first: { value: [1, 2], done: false }, + iteratorCleaned: true, + captureBefore: false, + captureAfter: false, + captureDefault: true, +}; diff --git a/src/compat/expansion/README.md b/src/compat/expansion/README.md new file mode 100644 index 00000000..eadba035 --- /dev/null +++ b/src/compat/expansion/README.md @@ -0,0 +1,54 @@ +# Additional compatibility profiles + +These adapters target workerd 1.20261012.1, compatibility date 2026-10-17. +`demo/tests/experiments/node-compat/expansion-contracts.probe.mjs` compares the +same operations in workerd, Chromium and WebKit, with both bundlers and both +page and Dedicated Worker execution. The native runner uses an installed npm +package and the same workerd expectations. These operation tests do not certify +whole modules. + +Implemented profiles include console's Workers stubs, sys aliasing, public +util/types predicates, crypto random integers/UUIDs/Web Crypto exports, +hash/HKDF/scrypt, the four Workers ECDH curves, crypto engine/secure-heap stubs, +writable memory-backed /tmp, module metadata, HTTP internal +helpers, adapter-owned secret and asymmetric KeyObjects, prime generation and +checking, incremental signatures, Brotli/Zstd codecs and CRC32. +Additional profiles cover process resource/permission/report stubs, its pinned +wall-clock hrtime behavior, and TLS hostname/ALPN/options contracts. Native runs +also test real TLS exchange and hostname mismatch rejection. + +The SDK starts a fresh /tmp volume for each local fetch dispatch. Handles opened +inside that request retain their volume; embedded bundle assets stay read-only. +Standalone imports outside SDK dispatch share a fallback volume. Copying embedded files to /tmp preserves immutable embedded bytes. Permission +changes are validated no-ops and statfs returns the pinned Workers zero values. +These checks do not cover every descriptor or cross-volume operation. Watching files is unsupported in Workers too. + +Brotli 1.1.0 and Zstd 1.5.7 use bundled, synchronously initialized WebAssembly. +The profile covers parameters, synchronous/callback operations, incremental +streams, flush/reset, byte accounting and output limits for synchronous +processing. Streaming output is not cumulatively capped by maxOutputLength. +The pinned source revisions and artifact hashes accompany the codecs; rebuild +with scripts/build-native-codecs.mjs and the pinned Emscripten SDK. Remaining +codec edge cases and inherited gzip/deflate behavior still require acceptance. +Scrypt uses a synchronous JavaScript backend, including for callback completion, +so large parameters can block the WebView. + +Adapter-created secret keys support copied raw/JWK export, equality, generation, +HMAC, HKDF and symmetric ciphers. KeyObject.from can retain a host CryptoKey, but +synchronous extraction of its opaque key material is unavailable. RSA, EC, Ed25519 and X25519 key generation and PEM/DER/JWK conversion use +bundled OpenSSL 3.5.9 WebAssembly; RSA/EC streaming and one-shot signatures +are compared with Workers and independent test signatures. This covers selected +algorithms and operations, not the whole crypto module. X509/Certificate, +additional key-generation options and remaining error contracts still need work. +The pinned revisions and hashes are in crypto/native-crypto.build.json; rebuild +with scripts/build-native-crypto.mjs and the pinned Emscripten SDK. Entropy comes +from the host crypto.getRandomValues; there is no noncryptographic fallback. +Direct Node TLS is implemented and tested through the native transport. +Existing-socket TLS wrapping throws before taking ownership or sending bytes; +actual TLS upgrade and full HTTP internal state contracts remain open. +Consult the generated completion report for remaining work. + +Workers reports `fips=true` because of its own crypto backend. The WebView's +JavaScript implementations do not establish FIPS compliance, so that flag is +not copied merely to match the export inventory. `setFips` and `setEngine` +retain Workers' unsupported-operation behavior. diff --git a/src/compat/expansion/index.spec.mjs b/src/compat/expansion/index.spec.mjs new file mode 100644 index 00000000..b168c4a0 --- /dev/null +++ b/src/compat/expansion/index.spec.mjs @@ -0,0 +1,1413 @@ +export const eventCases = { + primeNumbers: async function ({ crypto }) { + const capture = (fn) => { + try { + return { value: fn() ?? null }; + } catch (e) { + return { name: e.name, code: e.code ?? null, message: e.message }; + } + }; + const candidates = [ + 0n, + 1n, + 2n, + 3n, + 4n, + 17n, + 561n, + 1105n, + 18446744073709551557n, + ]; + const checked = candidates.map((value) => crypto.checkPrimeSync(value)); + const safe = crypto.generatePrimeSync(32, { safe: true, bigint: true }); + const constrained = crypto.generatePrimeSync(32, { + add: 12n, + rem: 11n, + bigint: true, + }); + const buffer = crypto.generatePrimeSync(32); + const log = []; + const async = await new Promise((resolve, reject) => { + crypto.checkPrime(17n, (error, value) => { + log.push("callback"); + error ? reject(error) : resolve(value); + }); + log.push("after"); + }); + const generated = await new Promise((resolve, reject) => + crypto.generatePrime(16, { bigint: true }, (error, value) => + error ? reject(error) : resolve(crypto.checkPrimeSync(value)), + ), + ); + const errors = [ + () => crypto.checkPrimeSync(-1n), + () => crypto.checkPrimeSync("17"), + () => crypto.checkPrimeSync(17n, { checks: 65 }), + () => crypto.checkPrimeSync(17n, { checks: -1 }), + () => crypto.checkPrimeSync(new Uint8Array(1025)), + () => crypto.generatePrimeSync(0), + () => crypto.generatePrimeSync(8193), + () => crypto.generatePrimeSync(16, { safe: 1 }), + () => crypto.generatePrimeSync(16, { add: 4n, rem: 3n }), + () => crypto.generatePrimeSync(2, { add: 12n, rem: 11n }), + ].map(capture); + return { + checked, + safe: + crypto.checkPrimeSync(safe) && crypto.checkPrimeSync((safe - 1n) / 2n), + safeBits: safe.toString(2).length, + remainder: String(constrained % 12n), + constrainedBits: constrained.toString(2).length, + buffer: { + brand: buffer instanceof ArrayBuffer, + bytes: buffer.byteLength, + prime: crypto.checkPrimeSync(buffer), + }, + async, + generated, + log, + errors, + }; + }, + asymmetricKeys: async function ({ crypto }) { + // Disposable fixture keys generated by independent Node crypto, never credentials. + const fixtures = { + rsa: { + privateKey: + "-----BEGIN PRIVATE KEY-----\nMIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKmqearRpQ+76PnZ\nQ8r2aFHbGae4GwWqLQDF15XxwtcDUUTytnIBmpxw8I5cs9YezIh2hZc/lYcW9Gmb\nXBTOaHtDgkR+hXxq1o0awFarEJMFW80w3j+68/syK11IvRhsbcGBQvw15SGoeaHQ\nhvWSN+IiTDKQYeJ328e7yjFh3Ct5AgMBAAECgYBhwVdYlHIGHr6dNhFZX5+7igG+\nINVw7hv/1f3g5urb941brHxyM3phqLDxVXhIZnZyKdfOzVPaAd/Q+TKUylhnvJQz\nf3b2YBdtOz4AIsMPWnTilDRi1Kwu5mvcF5gzlbBsleJMTjRRDWwG1Sxg69Yze/Rh\nnZ8kJTEye7nMaZPAAQJBANo0MndLMjNLLpin925wiDmLO5Vct6GnPGY1gfNbzVXl\n6uUs4oc5XolZDjsW97bYsn+Rip52hX5rqkeNYBncOJECQQDHDfYgGx48qFmb1gRU\nd8ikvDIWk9DurQvnjGcGfWvAzvtyw9ybk0CBpFghrF7izutj+j0VfnFWlNX9e612\nNXhpAkAy1nhvjMh8ZObNUEz4oSVL6uGN8hUih5kt4weM0HWtrqykimmYwcgBzgrf\nv4ElS6WCzUDznH+Lrb/1fb3HKKTRAkAc+QBBDhFpnMtmLlF1BfZTW/0iYiOACfn4\nmuwH+strRfU9cBq1Hkq+U/Br/k3VT27dn3eyoDPY+VLoUU8fLIs5AkAl7rPmRk0W\naVESr8259cVOXJZNfff+NDbTDO88/et+bARWUPPFopAOQhbRaHzoQN05WsAnDSl0\n3R6Dwk53bF0r\n-----END PRIVATE KEY-----\n", + publicKey: + "-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCpqnmq0aUPu+j52UPK9mhR2xmn\nuBsFqi0AxdeV8cLXA1FE8rZyAZqccPCOXLPWHsyIdoWXP5WHFvRpm1wUzmh7Q4JE\nfoV8ataNGsBWqxCTBVvNMN4/uvP7MitdSL0YbG3BgUL8NeUhqHmh0Ib1kjfiIkwy\nkGHid9vHu8oxYdwreQIDAQAB\n-----END PUBLIC KEY-----\n", + jwk: { + kty: "RSA", + n: "qap5qtGlD7vo-dlDyvZoUdsZp7gbBaotAMXXlfHC1wNRRPK2cgGanHDwjlyz1h7MiHaFlz-Vhxb0aZtcFM5oe0OCRH6FfGrWjRrAVqsQkwVbzTDeP7rz-zIrXUi9GGxtwYFC_DXlIah5odCG9ZI34iJMMpBh4nfbx7vKMWHcK3k", + e: "AQAB", + d: "YcFXWJRyBh6-nTYRWV-fu4oBviDVcO4b_9X94Obq2_eNW6x8cjN6Yaiw8VV4SGZ2cinXzs1T2gHf0PkylMpYZ7yUM3929mAXbTs-ACLDD1p04pQ0YtSsLuZr3BeYM5WwbJXiTE40UQ1sBtUsYOvWM3v0YZ2fJCUxMnu5zGmTwAE", + p: "2jQyd0syM0sumKf3bnCIOYs7lVy3oac8ZjWB81vNVeXq5SzihzleiVkOOxb3ttiyf5GKnnaFfmuqR41gGdw4kQ", + q: "xw32IBsePKhZm9YEVHfIpLwyFpPQ7q0L54xnBn1rwM77csPcm5NAgaRYIaxe4s7rY_o9FX5xVpTV_XutdjV4aQ", + dp: "MtZ4b4zIfGTmzVBM-KElS-rhjfIVIoeZLeMHjNB1ra6spIppmMHIAc4K37-BJUulgs1A85x_i62_9X29xyik0Q", + dq: "HPkAQQ4RaZzLZi5RdQX2U1v9ImIjgAn5-JrsB_rLa0X1PXAatR5KvlPwa_5N1U9u3Z93sqAz2PlS6FFPHyyLOQ", + qi: "Je6z5kZNFmlREq_NufXFTlyWTX33_jQ20wzvPP3rfmwEVlDzxaKQDkIW0Wh86EDdOVrAJw0pdN0eg8JOd2xdKw", + }, + signature: + "VZCB1w22hBa1DrzurqCnmUdaMXCFMWFCPmOg2IKfQGW48EsZCod4GpE07mJATLLjFVgdTppygeOUqvQK85/SD6jo3HNA270/ZANk4exXpj72lQziYslAY7wERfO9xozZwzAd2Mwg/XrUtlT4flGodizI0wCmGsOZ9ToqcSSjFKM=", + }, + ec: { + privateKey: + "-----BEGIN PRIVATE KEY-----\nMIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgkzAWEEq6Qf3Q3Zj8\njZzVPzjXi9v1UE4fUvSPCYDzIQ+hRANCAATUyxPEFq8wbhMtrw73FeZ4pAGrhRIV\n33P91jSkmz3i4hqV4Q4p8i4jxCmRxXjS8pmjSzVVtV1haS6lqKB3PqTW\n-----END PRIVATE KEY-----\n", + publicKey: + "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1MsTxBavMG4TLa8O9xXmeKQBq4US\nFd9z/dY0pJs94uIaleEOKfIuI8QpkcV40vKZo0s1VbVdYWkupaigdz6k1g==\n-----END PUBLIC KEY-----\n", + jwk: { + kty: "EC", + x: "1MsTxBavMG4TLa8O9xXmeKQBq4USFd9z_dY0pJs94uI", + y: "GpXhDinyLiPEKZHFeNLymaNLNVW1XWFpLqWooHc-pNY", + crv: "P-256", + d: "kzAWEEq6Qf3Q3Zj8jZzVPzjXi9v1UE4fUvSPCYDzIQ8", + }, + signature: + "MEYCIQD6Z6h2C9Ph77WTRPSzZiegB6hwdYGLY6piOyWM8h9iAQIhALPJTymfz9UQrYqJTuwvuFk3iM0laFYjEcueJYXPX67X", + }, + ed25519: { + privateKey: + "-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VwBCIEIOzFGVeuGidC3g/gfu6BLZHV0nkI1cOdcgJSZndBdLk5\n-----END PRIVATE KEY-----\n", + publicKey: + "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAZ9S/SKhncpbOeH+ppPVjBQnZl6SBN+2UCWsZPmqVc7U=\n-----END PUBLIC KEY-----\n", + jwk: { + crv: "Ed25519", + d: "7MUZV64aJ0LeD-B-7oEtkdXSeQjVw51yAlJmd0F0uTk", + x: "Z9S_SKhncpbOeH-ppPVjBQnZl6SBN-2UCWsZPmqVc7U", + kty: "OKP", + }, + signature: + "2Atk1x63ifZkxT1hOgEN32mT3U4Toiy3+659GbAgKFsMZi6Z2j0ZKTk8DsnXCllDzGB0LJKxnxnQEp0I/tAcCQ==", + }, + x25519: { + privateKey: + "-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VuBCIEIFgmCj/A/WL5EEgvvjyCUV0/+K/sxR62Z6WlK/Vz1ydG\n-----END PRIVATE KEY-----\n", + publicKey: + "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VuAyEACs62/8koQj99zkBorRDHAvE3uptEtZIjbmL6ogtsRwU=\n-----END PUBLIC KEY-----\n", + jwk: { + crv: "X25519", + d: "WCYKP8D9YvkQSC--PIJRXT_4r-zFHrZnpaUr9XPXJ0Y", + x: "Cs62_8koQj99zkBorRDHAvE3uptEtZIjbmL6ogtsRwU", + kty: "OKP", + }, + signature: null, + peer: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VuAyEA3lvtx86rEZf58Uf9X9OIEYtpWglahuEwoK3lzb9kxC0=\n-----END PUBLIC KEY-----\n", + secret: + "c47b7be86dc7effc5514183876c5377825417f783b1ae4b8f5edd6afcf0c4922", + }, + }; + const decode = (value) => + Uint8Array.from(atob(value), (c) => c.charCodeAt(0)); + const data = new TextEncoder().encode("Workers portable key"); + const result = {}; + for (const [type, fixture] of Object.entries(fixtures)) { + const privateKey = crypto.createPrivateKey(fixture.privateKey); + const publicKey = crypto.createPublicKey(privateKey); + const imported = crypto.createPublicKey(fixture.publicKey); + const jwk = crypto.createPrivateKey({ key: fixture.jwk, format: "jwk" }); + const der = privateKey.export({ format: "der", type: "pkcs8" }); + const roundtrip = crypto.createPrivateKey({ + key: der, + format: "der", + type: "pkcs8", + }); + const details = privateKey.asymmetricKeyDetails; + const entry = { + type: privateKey.type, + algorithm: privateKey.asymmetricKeyType, + details: JSON.parse( + JSON.stringify(details, (_, value) => + typeof value === "bigint" ? value.toString() : value, + ), + ), + publicPem: publicKey.export({ format: "pem", type: "spki" }), + publicEqual: publicKey.equals(imported), + jwkEqual: privateKey.equals(jwk), + derEqual: privateKey.equals(roundtrip), + publicJwk: publicKey.export({ format: "jwk" }), + privateJwk: privateKey.export({ format: "jwk" }), + }; + entry.dhValidation = [ + {}, + { publicKey }, + { publicKey: {}, privateKey }, + { publicKey: privateKey, privateKey }, + { publicKey, privateKey: publicKey }, + { publicKey: fixture.publicKey, privateKey }, + { publicKey, privateKey: fixture.privateKey }, + { + publicKey, + privateKey: crypto.createPrivateKey( + fixtures[type === "rsa" ? "ec" : "rsa"].privateKey, + ), + }, + ].map((options) => { + try { + crypto.diffieHellman(options); + return null; + } catch (e) { + return { name: e.name, code: e.code ?? null }; + } + }); + if (type === "x25519") { + try { + entry.secret = crypto + .diffieHellman({ + privateKey, + publicKey: crypto.createPublicKey(fixture.peer), + }) + .toString("hex"); + } catch (e) { + entry.error = { name: e.name, message: e.message }; + } + } else { + const algorithm = type === "ed25519" ? null : "sha256"; + const signature = crypto.sign(algorithm, data, privateKey); + entry.verifies = crypto.verify(algorithm, data, publicKey, signature); + entry.independent = crypto.verify( + algorithm, + data, + publicKey, + decode(fixture.signature), + ); + entry.tampered = crypto.verify( + algorithm, + new Uint8Array([0]), + publicKey, + signature, + ); + if (type !== "ed25519") { + const signer = crypto.createSign("sha256"); + signer.update(data.subarray(0, 3)); + signer.update(data.subarray(3)); + const streamed = signer.sign(privateKey); + const verifier = crypto.createVerify("sha256"); + verifier.update(data.subarray(0, 5)); + verifier.update(data.subarray(5)); + entry.streaming = { + valid: verifier.verify(publicKey, streamed), + independent: crypto + .createVerify("sha256") + .update(data) + .verify(publicKey, decode(fixture.signature)), + cross: crypto.verify("sha256", data, publicKey, streamed), + constructor: signer instanceof crypto.Sign, + }; + if (type === "rsa") + entry.streaming.signature = streamed.toString("base64"); + const failure = (run) => { + try { + run(); + return null; + } catch (error) { + return { + name: error.name, + message: error.message, + code: error.code ?? null, + }; + } + }; + entry.streaming.errors = [ + failure(() => signer.update(data)), + failure(() => signer.sign(privateKey)), + failure(() => verifier.update(data)), + failure(() => verifier.verify(publicKey, streamed)), + failure(() => crypto.createSign("not-a-digest")), + failure(() => crypto.createVerify("not-a-digest")), + ]; + const encoded = crypto + .createSign("sha256") + .update(data) + .sign({ + key: fixture.privateKey, + ...(type === "ec" + ? { dsaEncoding: "ieee-p1363" } + : { padding: 6, saltLength: 0 }), + }); + entry.streaming.options = crypto + .createVerify("sha256") + .update(data) + .verify( + { + key: fixture.publicKey, + ...(type === "ec" + ? { dsaEncoding: "ieee-p1363" } + : { padding: 6, saltLength: 0 }), + }, + encoded, + ); + } + if (type === "ec") { + const encoded = crypto.sign("sha256", data, { + key: fixture.privateKey, + dsaEncoding: "ieee-p1363", + }); + entry.p1363 = { + length: encoded.length, + valid: crypto.verify( + "sha256", + data, + { key: fixture.publicKey, dsaEncoding: "ieee-p1363" }, + encoded, + ), + }; + } + if (type === "rsa") { + entry.rsaComposition = [false, true].map((wrapped) => { + try { + const pub = wrapped ? { key: publicKey } : publicKey; + const priv = wrapped ? { key: privateKey } : privateKey; + const encrypted = crypto.publicEncrypt(pub, data); + const signed = crypto.privateEncrypt(priv, data); + return [ + crypto.privateDecrypt(priv, encrypted).toString("hex"), + crypto.publicDecrypt(pub, signed).toString("hex"), + ]; + } catch (e) { + return { name: e.name, code: e.code ?? null }; + } + }); + entry.rsaOptions = [ + { oaepLabel: new Uint8Array([1]) }, + { padding: 4, oaepLabel: new Uint8Array([1]), oaepHash: "sha256" }, + { padding: 4, oaepLabel: new Uint8Array([1]), oaepHash: "sha1" }, + { oaepLabel: 42 }, + ].map((options) => { + try { + const encrypted = crypto.publicEncrypt( + { key: fixture.publicKey, ...options }, + data, + ); + const decoded = crypto.privateDecrypt( + { key: fixture.privateKey, ...options }, + encrypted, + ); + let mismatch; + try { + crypto.privateDecrypt( + { + key: fixture.privateKey, + ...options, + oaepLabel: new Uint8Array([2]), + }, + encrypted, + ); + mismatch = null; + } catch (e) { + mismatch = { name: e.name, message: e.message }; + } + return { decoded: decoded.toString("hex"), mismatch }; + } catch (e) { + return { name: e.name, code: e.code ?? null, message: e.message }; + } + }); + const signed = crypto.sign("sha256", data, { + key: fixture.privateKey, + padding: 6, + saltLength: 0, + }); + entry.pss = crypto.verify( + "sha256", + data, + { key: fixture.publicKey, padding: 6, saltLength: 0 }, + signed, + ); + const passphrase = new Uint8Array([112, 0, 97]); + entry.encrypted = ["pem", "der"].map((format) => { + const encrypted = privateKey.export({ + type: "pkcs8", + format, + cipher: "aes-256-cbc", + passphrase, + }); + return crypto + .createPrivateKey({ + key: encrypted, + type: "pkcs8", + format, + passphrase, + }) + .equals(privateKey); + }); + } + + if (type !== "ec") entry.signature = signature.toString("base64"); + entry.async = await new Promise((resolve, reject) => + crypto.sign(algorithm, data, privateKey, (error, signed) => + error + ? reject(error) + : crypto.verify( + algorithm, + data, + publicKey, + signed, + (err, valid) => (err ? reject(err) : resolve(valid)), + ), + ), + ); + } + result[type] = entry; + } + result.timing = [ + crypto.timingSafeEqual(data, new Uint8Array(data)), + crypto.timingSafeEqual(new Uint8Array([1]), new Uint8Array([2])), + ]; + return result; + }, + asymmetricGeneration: function ({ crypto }) { + return ["rsa", "ec", "ed25519", "x25519"].map((type) => { + const { privateKey, publicKey } = crypto.generateKeyPairSync( + type, + type === "rsa" + ? { modulusLength: 1024 } + : type === "ec" + ? { namedCurve: "prime256v1" } + : {}, + ); + const exported = privateKey.export({ format: "pem", type: "pkcs8" }); + return { + type, + privateType: privateKey.type, + publicType: publicKey.type, + equal: crypto.createPrivateKey(exported).equals(privateKey), + publicEqual: crypto.createPublicKey(privateKey).equals(publicKey), + }; + }); + }, + + processClock: function ({ process }) { + const now = Date.now; + try { + Date.now = () => 1234567; + const invalid = [null, 12, [], [1], [1, 2, 3]].map((value) => { + try { + return process.hrtime(value); + } catch (e) { + return { name: e.name, code: e.code, message: e.message }; + } + }); + return { + absolute: process.hrtime(), + bigint: String(process.hrtime.bigint()), + delta: process.hrtime([1233, 900000000]), + invalid, + }; + } finally { + Date.now = now; + } + }, + processStubs: function ({ process }) { + const call = (name, args = []) => { + try { + return { value: process[name](...args) ?? null }; + } catch (e) { + return { + name: e.name, + code: e.code ?? null, + message: e.message, + syscall: e.syscall ?? null, + errno: e.errno ?? null, + }; + } + }; + const simple = [ + "ref", + "unref", + "setSourceMapsEnabled", + "getSourceMapsSupport", + "setUncaughtExceptionCaptureCallback", + "hasUncaughtExceptionCaptureCallback", + "kill", + "binding", + "dlopen", + "getActiveResourcesInfo", + "memoryUsage", + "resourceUsage", + "threadCpuUsage", + "cpuUsage", + "_linkedBinding", + "_getActiveRequests", + "_getActiveHandles", + "_kill", + "constrainedMemory", + "availableMemory", + "execve", + "_fatalException", + "_tickCallback", + "_debugProcess", + "_debugEnd", + "_startProfilerIdleNotifier", + "_stopProfilerIdleNotifier", + "send", + "uptime", + "getegid", + "getgid", + "geteuid", + "getuid", + "getgroups", + ].map((name) => [name, call(name)]); + const permissions = [ + "setegid", + "setgid", + "seteuid", + "setuid", + "setgroups", + "initgroups", + ].map((name) => [ + name, + [0, 1, "0", null, undefined].map((value) => call(name, [value])), + ]); + const nested = [ + "permission.has", + "report.getReport", + "report.writeReport", + "finalization.register", + "finalization.registerBeforeExit", + "finalization.unregister", + ].map((path) => { + const [a, b] = path.split("."); + try { + return [path, { value: process[a][b]() ?? null }]; + } catch (e) { + return [ + path, + { name: e.name, code: e.code ?? null, message: e.message }, + ]; + } + }); + const properties = Object.fromEntries( + [ + "arch", + "pid", + "ppid", + "exitCode", + "channel", + "connected", + "debugPort", + "noDeprecation", + "traceDeprecation", + "throwDeprecation", + "sourceMapsEnabled", + "execPath", + "release", + "moduleLoadList", + "_preload_modules", + "domain", + "_exiting", + ].map((name) => [name, process[name] ?? null]), + ); + return { + simple, + permissions, + nested, + properties, + flags: Array.from(process.allowedNodeEnvironmentFlags), + }; + }, + tlsHelpers: function ({ tls }) { + const capture = (fn) => { + try { + const result = fn(); + return result === undefined ? null : result; + } catch (e) { + return { name: e.name, code: e.code ?? null, message: e.message }; + } + }; + const certificates = [ + ["api.example.com", { subjectaltname: "DNS:*.example.com" }], + ["nested.api.example.com", { subjectaltname: "DNS:*.example.com" }], + ["example.com", { subject: { CN: "example.com" } }], + ["EXAMPLE.COM.", { subjectaltname: "DNS:example.com" }], + [ + "example.com", + { subjectaltname: "DNS:other.com", subject: { CN: "example.com" } }, + ], + ["127.0.0.1", { subjectaltname: "IP Address:127.0.0.1" }], + ["2001:db8::1", { subjectaltname: "IP Address:2001:0db8:0:0:0:0:0:1" }], + ["::ffff:192.0.2.1", { subjectaltname: "IP Address:::ffff:c000:201" }], + ["example.com", { subjectaltname: 'DNS:"bad' }], + ["example.com", {}], + ].map(([host, cert]) => + capture(() => { + const e = tls.checkServerIdentity(host, cert); + return e + ? { + name: e.name, + code: e.code, + message: e.message, + reason: e.reason, + host: e.host, + sameCert: e.cert === cert, + } + : null; + }), + ); + const protocols = [ + ["h2", "http/1.1"], + ["é"], + new Uint8Array([2, 104, 50]), + new DataView(new Uint8Array([0, 2, 104, 50, 0]).buffer, 1, 3), + ["x".repeat(256)], + null, + ].map((value) => + capture(() => { + const out = {}; + tls.convertALPNProtocols(value, out); + return out.ALPNProtocols ? Array.from(out.ALPNProtocols) : null; + }), + ); + const unsupported = [ + tls.createServer, + tls.Server, + tls.getCiphers, + tls.createSecurePair, + ].map((fn) => capture(() => fn())); + const validations = [ + { enableTrace: true }, + { isServer: true }, + { server: {} }, + { requestCert: true }, + { rejectUnauthorized: false }, + { ALPNProtocols: [] }, + { SNICallback: () => {} }, + { requestOCSP: true }, + { secureContext: {} }, + { pskCallback: () => {} }, + { checkServerIdentity: 123 }, + { checkServerIdentity: () => {} }, + ].map((opts) => + capture(() => { + const socket = new tls.TLSSocket(undefined, opts); + socket.destroy(); + return null; + }), + ); + const ctx = tls.createSecureContext(); + return { + certificates, + protocols, + unsupported, + validations, + context: ctx instanceof tls.SecureContext, + contextValue: ctx.context ?? null, + constants: [ + tls.CLIENT_RENEG_LIMIT, + tls.CLIENT_RENEG_WINDOW, + tls.DEFAULT_CIPHERS, + tls.DEFAULT_ECDH_CURVE, + tls.DEFAULT_MIN_VERSION, + tls.DEFAULT_MAX_VERSION, + tls.rootCertificates, + ], + }; + }, + aliases: function ({ sys, util, types }) { + return { + same: sys.default === util.default, + format: sys.format("%s:%d", "value", 3), + typesSame: types.default === util.types, + predicates: [ + types.isMap(new Map()), + types.isMap({}), + types.isUint8Array(new Uint8Array()), + types.isDataView(new DataView(new ArrayBuffer(1))), + types.isDate(new Date(0)), + types.isBoxedPrimitive(Object(1n)), + types.isArrayBufferView(new Uint16Array()), + types.isArrayBuffer(new ArrayBuffer(1)), + ], + }; + }, + consoleStubs: function ({ console: api }) { + const errors = []; + for (const name of ["Console", "context", "createTask"]) { + try { + api[name](); + errors.push(null); + } catch (e) { + errors.push({ name: e.name, code: e.code, message: e.message }); + } + } + return { + errors, + defaultIdentity: api.default === globalThis.console, + prototypes: [ + "log", + "warn", + "error", + "table", + "context", + "createTask", + ].map((n) => api.Console.prototype[n] === api[n]), + }; + }, + cryptoMetadata: function ({ crypto: c }) { + const errors = {}; + for (const name of ["setEngine", "setFips"]) { + try { + c[name](); + } catch (error) { + errors[name] = { + name: error.name, + code: error.code, + message: error.message, + }; + } + } + const curves = c.getCurves(); + const exchanges = curves.map((curve) => { + const alice = c.createECDH(curve), + bob = c.createECDH(curve); + alice.setPrivateKey( + c.createHash("sha256").update("fixture alice").digest().subarray(0, 16), + ); + bob.setPrivateKey( + c.createHash("sha256").update("fixture bob").digest().subarray(0, 16), + ); + const a = alice.getPublicKey(), + b = bob.getPublicKey(); + const left = alice.computeSecret(b), + right = bob.computeSecret(a); + const converted = ["compressed", "uncompressed", "hybrid"].map( + (format) => { + try { + const encoded = c.ECDH.convertKey( + a, + curve, + undefined, + undefined, + format, + ); + return [ + encoded.toString("hex"), + bob.computeSecret(encoded).equals(right), + ]; + } catch (e) { + return { name: e.name, message: e.message }; + } + }, + ); + const copy = new c.ECDH(curve); + const privateBytes = alice.getPrivateKey(); + const setResult = copy.setPrivateKey( + new DataView( + privateBytes.buffer, + privateBytes.byteOffset, + privateBytes.byteLength, + ), + ); + const generated = c.ECDH(curve); + generated.generateKeys(); + const failures = []; + for (const run of [ + () => new c.ECDH("not-a-curve"), + () => new c.ECDH(curve).getPrivateKey(), + () => new c.ECDH(curve).getPublicKey(), + () => new c.ECDH(curve).computeSecret(a), + () => copy.setPrivateKey(new Uint8Array([0])), + () => copy.computeSecret(new Uint8Array([1])), + () => c.ECDH.convertKey(new Uint8Array([1]), curve), + ]) { + try { + run(); + failures.push(null); + } catch (e) { + failures.push({ name: e.name, message: e.message }); + } + } + return { + curve, + converted, + failures, + instance: copy instanceof c.ECDH, + setReturnsUndefined: setResult === undefined, + copied: copy.getPublicKey().equals(a), + generated: generated + .computeSecret(a) + .equals(alice.computeSecret(generated.getPublicKey())), + empty: c.ECDH.convertKey(new Uint8Array(), "not-a-curve").length, + bytes: left.length, + equal: left.equals(right), + secret: left.toString("hex"), + publicKey: a.toString("hex"), + }; + }); + return { curves, exchanges, heap: c.secureHeapUsed(), errors }; + }, + secretKeys: async function ({ crypto: c, types }) { + const input = new Uint8Array([1, 2, 3, 4]); + const key = c.createSecretKey(input); + input.fill(0); + const raw = key.export(); + raw.fill(0); + const options = {}; + key.export(options); + const hmac = c.createHmac("sha256", key).update("fixture").digest("hex"); + const brands = []; + const streamResults = []; + const cipherKey = c.createSecretKey( + c.createHash("sha256").update("cipher key").digest(), + ); + const iv = c.createHash("sha256").update("iv").digest().subarray(0, 16); + const cipher = c.createCipheriv("aes-256-cbc", cipherKey, iv); + for (const value of [ + new c.Hmac("sha256", key), + c.createHmac("md5", key), + c.createCipheriv("aes-256-cbc", cipherKey, iv), + new c.Decipheriv("aes-256-cbc", cipherKey, iv), + ]) { + const Class = value.constructor; + brands.push([ + Class.name, + Object.getPrototypeOf(value) === Class.prototype, + value instanceof c.Hmac, + value instanceof c.Cipheriv, + value instanceof c.Decipheriv, + ]); + } + for (const algorithm of ["sha256", "sha384", "sha512"]) { + const instance = c.createHmac(algorithm, key); + streamResults.push( + await new Promise((resolve, reject) => { + instance.on("data", (data) => resolve(data.toString("hex"))); + instance.on("error", reject); + instance.write("fix"); + instance.end("ture"); + }), + ); + } + const streamCipher = c.createCipheriv("aes-256-cbc", cipherKey, iv); + const streamDecipher = c.createDecipheriv("aes-256-cbc", cipherKey, iv); + const streamed = new Promise((resolve, reject) => { + let text = ""; + streamDecipher.setEncoding("utf8"); + streamDecipher.on("data", (chunk) => { + text += chunk; + }); + streamDecipher.on("end", () => resolve(text)); + streamDecipher.on("error", reject); + streamCipher.on("error", reject); + streamCipher.pipe(streamDecipher); + }); + streamCipher.write("mes"); + streamCipher.end("sage"); + const encrypted = + cipher.update("message", "utf8", "hex") + cipher.final("hex"); + const generated = await new Promise((resolve, reject) => + c.generateKey("hmac", { length: 9 }, (error, value) => + error ? reject(error) : resolve(value.symmetricKeySize), + ), + ); + const constructors = []; + for (const Class of [ + c.KeyObject, + c.SecretKeyObject, + c.PublicKeyObject, + c.PrivateKeyObject, + ]) { + try { + new Class(); + constructors.push(null); + } catch (e) { + constructors.push({ name: e.name, message: e.message }); + } + } + return { + type: key.type, + size: key.symmetricKeySize, + constructor: key.constructor.name, + tag: Object.prototype.toString.call(key), + export: key.export().toString("hex"), + jwk: key.export({ format: "jwk" }), + equal: key.equals(c.createSecretKey(new Uint8Array([1, 2, 3, 4]))), + unequal: key.equals(c.createSecretKey("different")), + branded: types.isKeyObject(key), + fake: types.isKeyObject({}), + options, + hmac, + encodedHmac: c + .createHmac("sha256", "aa", { encoding: "hex" }) + .update("message") + .digest("hex"), + brands, + streamResults, + streamed: await streamed, + encrypted, + generated, + aes: c.generateKeySync("aes", { length: 192 }).symmetricKeySize, + constructors, + }; + }, + + cryptoRandom: async function ({ crypto: c }) { + const values = Array.from({ length: 200 }, () => c.randomInt(-3, 9)); + const asynchronous = await new Promise((resolve, reject) => + c.randomInt(1, (err, n) => (err ? reject(err) : resolve(n))), + ); + const errors = []; + for (const args of [[0], [3, 3], [1.5], ["x"], [0, 2 ** 48]]) { + try { + c.randomInt(...args); + errors.push(null); + } catch (e) { + errors.push({ name: e.name, code: e.code }); + } + } + return { + range: values.every((n) => Number.isInteger(n) && n >= -3 && n < 9), + asynchronous, + uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test( + c.randomUUID(), + ), + webcrypto: c.webcrypto === globalThis.crypto, + subtle: c.subtle === globalThis.crypto.subtle, + errors, + }; + }, + cryptoHashKdf: async function ({ crypto: c }) { + const hex = (value) => + Array.from(new Uint8Array(value)) + .map((n) => n.toString(16).padStart(2, "0")) + .join(""); + const result = { + hash: c.hash("sha256", "abc"), + bytes: hex(c.hash("sha256", new Uint8Array([97, 98, 99]), "buffer")), + hkdf: hex(c.hkdfSync("sha256", "key", "salt", "info", 42)), + empty: hex(c.hkdfSync("sha256", "", "", "", 0)), + }; + result.hkdfAsync = await new Promise((resolve, reject) => + c.hkdf("sha256", "key", "salt", "info", 42, (e, b) => + e ? reject(e) : resolve(hex(b)), + ), + ); + result.scrypt = hex( + c.scryptSync("password", "salt", 32, { N: 16, r: 1, p: 1 }), + ); + result.scryptAsync = await new Promise((resolve, reject) => + c.scrypt( + "password", + "salt", + 32, + { cost: 16, blockSize: 1, parallelization: 1 }, + (e, b) => (e ? reject(e) : resolve(hex(b))), + ), + ); + return result; + }, + cryptoInvalid: function ({ crypto: c }) { + const errors = []; + const calls = [ + () => c.hash(3, "x"), + () => c.hash("sha256", null), + () => c.hkdfSync("sha256", "a", "b", "c", -1), + () => c.hkdfSync("sha256", "a", "b", new Uint8Array(1025), 1), + () => c.scryptSync("a", "b", 16, { N: 3 }), + () => c.scryptSync("a", "b", 16, { N: 16, cost: 16 }), + () => c.scryptSync("a", "b", 16, { N: 16, r: 1, maxmem: 1 }), + () => c.randomUUID({ disableEntropyCache: 1 }), + ]; + for (const call of calls) { + try { + call(); + errors.push(null); + } catch (e) { + errors.push({ name: e.name, code: e.code }); + } + } + return errors; + }, + + fsWrites: function ({ fs }) { + const dir = "/tmp/cf-writes"; + fs.mkdirSync(dir, { recursive: true }); + try { + const wrote = fs.writeFileSync(dir + "/a", "hello"); + const appended = fs.appendFileSync(dir + "/a", " world"); + const fd = fs.openSync(dir + "/a", "r+"); + const bytes = new Uint8Array(5); + const read = fs.readSync(fd, bytes, 0, 5, 0); + const written = fs.writeSync(fd, new Uint8Array([72]), 0, 1, 0); + fs.ftruncateSync(fd, 5); + const size = fs.fstatSync(fd).size; + fs.closeSync(fd); + return { + wrote, + appended, + read, + written, + size, + data: fs.readFileSync(dir + "/a", "utf8"), + bytes: Array.from(bytes), + }; + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } + }, + fsDirectories: function ({ fs }) { + const dir = "/tmp/cf-directories"; + fs.mkdirSync(dir, { recursive: true }); + try { + fs.writeFileSync(dir + "/source", "value"); + fs.copyFileSync(dir + "/source", dir + "/copy"); + fs.renameSync(dir + "/copy", dir + "/renamed"); + fs.symlinkSync(dir + "/source", dir + "/link"); + return { + entries: fs.readdirSync(dir).sort(), + link: fs.lstatSync(dir + "/link").isSymbolicLink(), + target: fs.readlinkSync(dir + "/link"), + resolved: fs.realpathSync(dir + "/link"), + data: fs.readFileSync(dir + "/link", "utf8"), + size: fs.statSync(dir + "/renamed").size, + }; + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } + }, + fsPromises: async function ({ fs }) { + const p = fs.promises, + dir = "/tmp/cf-promises"; + await p.mkdir(dir, { recursive: true }); + try { + const handle = await p.open(dir + "/file", "w+"); + try { + await handle.writeFile("abc"); + const buffer = new Uint8Array(3); + const read = await handle.read(buffer, 0, 3, 0); + return { + read: read.bytesRead, + buffer: Array.from(buffer), + size: (await handle.stat()).size, + }; + } finally { + await handle.close(); + } + } finally { + await p.rm(dir, { recursive: true, force: true }); + } + }, + fsCallbacks: async function ({ fs }) { + const dir = "/tmp/cf-callbacks"; + fs.mkdirSync(dir, { recursive: true }); + try { + await new Promise((resolve, reject) => + fs.writeFile(dir + "/file", "abc", (error) => + error ? reject(error) : resolve(), + ), + ); + const data = await new Promise((resolve, reject) => + fs.readFile(dir + "/file", "utf8", (error, data) => + error ? reject(error) : resolve(data), + ), + ); + const errors = []; + for (const fn of [ + () => fs.watch(dir), + () => fs.watchFile(dir), + () => fs.unwatchFile(dir), + () => fs.readFileSync(dir + "/missing"), + ]) { + try { + fn(); + errors.push(null); + } catch (e) { + errors.push(e.code); + } + } + return { data, errors }; + } finally { + fs.rmSync(dir, { recursive: true, force: true }); + } + }, + brotli: async function ({ zlib: z }) { + const text = "hello world hello world hello world"; + const input = new TextEncoder().encode(text); + const compressed = z.brotliCompressSync(input, { + params: { [z.constants.BROTLI_PARAM_QUALITY]: 4 }, + }); + const decoded = new TextDecoder().decode( + z.brotliDecompressSync(compressed), + ); + const asyncDecoded = await new Promise((resolve, reject) => + z.brotliDecompress(compressed, (e, b) => + e ? reject(e) : resolve(new TextDecoder().decode(b)), + ), + ); + const stream = z.createBrotliCompress({ + params: { [z.constants.BROTLI_PARAM_QUALITY]: 4 }, + }); + const parts = []; + const done = new Promise((resolve, reject) => { + stream.on("data", (b) => parts.push(b)); + stream.on("error", reject); + stream.on("end", resolve); + }); + stream.write(input.subarray(0, 4)); + stream.end(input.subarray(4)); + await done; + const joined = new Uint8Array(parts.reduce((n, b) => n + b.length, 0)); + let offset = 0; + for (const b of parts) { + joined.set(b, offset); + offset += b.length; + } + return { + decoded, + asyncDecoded, + stream: new TextDecoder().decode(z.brotliDecompressSync(joined)), + crc: z.crc32("hello"), + incremental: z.crc32("lo", z.crc32("hel")), + }; + }, + + brotliErrors: function ({ zlib: z }) { + const outcomes = []; + const compressed = z.brotliCompressSync(new Uint8Array(100)); + for (const run of [ + () => z.brotliDecompressSync(new Uint8Array()), + () => z.brotliDecompressSync(new Uint8Array([255, 255, 255])), + () => z.brotliDecompressSync(compressed, { maxOutputLength: 10 }), + ]) { + try { + run(); + outcomes.push("success"); + } catch (error) { + outcomes.push({ + name: error.name, + message: error.message, + code: error.code, + }); + } + } + return outcomes; + }, + + codecProfiles: async function ({ zlib: z }) { + const input = new TextEncoder().encode("streaming fixture ".repeat(2000)); + const result = {}; + for (const name of ["brotli", "zstd"]) { + const prefix = name === "brotli" ? "Brotli" : "Zstd"; + const options = { + chunkSize: 256, + params: name === "brotli" ? { 0: 1, 1: 4, 2: 20 } : { 100: 5, 201: 1 }, + }; + const compressed = z[name + "CompressSync"](input, options); + const decoded = z[name + "DecompressSync"](compressed); + const info = z[name + "CompressSync"](input, { ...options, info: true }); + const stream = z["create" + prefix + "Compress"](options); + stream.reset(); + const parts = []; + stream.on("data", (chunk) => parts.push(chunk)); + const done = new Promise((resolve, reject) => { + stream.on("end", resolve); + stream.on("error", reject); + }); + stream.write(input.subarray(0, 17000)); + await new Promise((resolve, reject) => { + stream.once("error", reject); + stream.flush(resolve); + }); + const flushed = parts.length > 0; + stream.end(input.subarray(17000)); + await done; + const joined = new Uint8Array(parts.reduce((n, b) => n + b.length, 0)); + let offset = 0; + for (const part of parts) { + joined.set(part, offset); + offset += part.length; + } + const decoder = z["create" + prefix + "Decompress"]({ chunkSize: 128 }); + let decodedLength = 0, + decodedCrc = 0; + decoder.on("data", (b) => { + decodedLength += b.length; + decodedCrc = z.crc32(b, decodedCrc); + }); + const decoderDone = new Promise((resolve, reject) => { + decoder.on("end", resolve); + decoder.on("error", reject); + }); + for (let i = 0; i < joined.length; i += 7) + decoder.write(joined.subarray(i, i + 7)); + decoder.end(); + await decoderDone; + result[name] = { + length: decoded.length, + crc: z.crc32(decoded), + flushed, + decodedLength, + decodedCrc, + bytesWritten: stream.bytesWritten, + info: { + type: info.engine.constructor.name, + bytesWritten: info.engine.bytesWritten, + roundTrip: z[name + "DecompressSync"](info.buffer).length, + }, + }; + } + return result; + }, + + codecErrors: function ({ zlib: z }) { + const out = {}; + for (const name of ["Brotli", "Zstd"]) { + const values = []; + for (const options of [ + { chunkSize: 1 }, + { params: { 999: 1 } }, + { params: { 1: "bad" } }, + { flush: 99 }, + { finishFlush: -1 }, + { maxOutputLength: 0 }, + ]) { + try { + const engine = new z[name + "Compress"](options); + engine.destroy(); + values.push(null); + } catch (error) { + values.push({ + name: error.name, + code: error.code, + message: error.message, + }); + } + } + out[name] = values; + } + return out; + }, + + fsMetadata: async function ({ fs }) { + const path = "/tmp/metadata"; + fs.writeFileSync(path, "data", { mode: 0o600 }); + const before = fs.statSync(path); + fs.chmodSync(path, 0); + await fs.promises.chown(path, 123, 456); + const handle = await fs.promises.open(path, "r+"); + await handle.chmod(0); + await handle.chown(123, 456); + const after = await handle.stat(); + await handle.close(); + fs.mkdirSync("/tmp/metadata-dir", { mode: 0o700 }); + const mode = fs.statSync("/tmp/metadata-dir").mode; + fs.rmSync(path); + fs.rmdirSync("/tmp/metadata-dir"); + return { + before: [before.mode, before.uid, before.gid], + after: [after.mode, after.uid, after.gid], + directoryMode: mode, + statfs: fs.statfsSync("/missing"), + bigint: Object.values( + await fs.promises.statfs("/missing", { bigint: true }), + ).map(String), + }; + }, + + streamCancellation: async function ({ + streams: { ReadableStream, WritableStream }, + }) { + const tee = []; + for (const bytes of [false, true]) + for (const reverse of [false, true]) { + let reason; + const source = new ReadableStream({ + ...(bytes ? { type: "bytes" } : {}), + cancel(value) { + reason = value; + }, + }); + const pair = source.tee(); + const first = reverse ? 1 : 0, + second = 1 - first; + const a = pair[first].getReader().cancel("first"); + const b = pair[second].cancel("last"); + await Promise.all([a, b]); + tee.push(reason); + } + const pipes = []; + for (const options of [ + {}, + { preventCancel: true }, + { preventAbort: true }, + { preventCancel: true, preventAbort: true }, + ]) { + const events = []; + let controller, + settled = false; + const source = new ReadableStream({ + start(c) { + controller = c; + }, + cancel(reason) { + events.push(["cancel", reason]); + }, + }); + const sink = new WritableStream({ + write(value) { + events.push(["write", value]); + }, + abort(reason) { + events.push(["abort", reason]); + }, + }); + const signal = new AbortController(); + const done = source + .pipeTo(sink, { ...options, signal: signal.signal }) + .then( + () => { + settled = true; + }, + (reason) => { + settled = true; + events.push(["reject", reason]); + }, + ); + signal.abort("stop"); + await new Promise((resolve) => setTimeout(resolve, 10)); + const before = { settled, events: events.slice() }; + controller.enqueue(1); + await done; + pipes.push({ + before, + events, + sourceLocked: source.locked, + sinkLocked: sink.locked, + }); + } + return { tee, pipes }; + }, + + moduleMetadata: function ({ module: m }) { + const errors = {}; + for (const name of [ + "register", + "registerHooks", + "runMain", + "syncBuiltinESMExports", + "wrap", + "_debug", + "_findPath", + "_initPaths", + "_load", + "_resolveFilename", + "_resolveLookupPaths", + "_nodeModulePaths", + "findSourceMap", + "findPackageJSON", + "setSourceMapsSupport", + "stripTypeScriptTypes", + "SourceMap", + ]) { + try { + m[name](); + errors[name] = null; + } catch (e) { + errors[name] = { name: e.name, code: e.code, message: e.message }; + } + } + return { + errors, + compile: m.enableCompileCache() === undefined, + dir: m.getCompileCacheDir() === undefined, + flush: m.flushCompileCache() === undefined, + maps: m.getSourceMapsSupport(), + builtin: [ + "crypto", + "node:crypto", + "fs/promises", + "node:test", + "test", + "unknown", + ].map((n) => m.isBuiltin(n)), + }; + }, + httpInternals: function ({ + httpCommon: c, + httpOutgoing: o, + httpServer: s, + http, + }) { + const target = {}; + s.storeHTTPOptions.call(target, { + requestTimeout: 12000, + headersTimeout: 5000, + requireHostHeader: false, + }); + const errors = []; + for (const fn of [ + () => s.setupConnectionsTracking(), + () => s._connectionListener(), + () => + s.storeHTTPOptions.call({}, { requestTimeout: 1, headersTimeout: 2 }), + ]) { + try { + fn(); + errors.push(null); + } catch (e) { + errors.push({ name: e.name, code: e.code }); + } + } + const closed = []; + s.httpServerPreClose({ + closeIdleConnections() { + closed.push(true); + }, + }); + return { + tokens: ["X-Test", "bad space", ""].map((n) => c._checkIsHttpToken(n)), + headers: ["ok", "bad\r\nvalue"].map((n) => c._checkInvalidHeaderChar(n)), + methods: c.methods === http.METHODS, + classes: + o.OutgoingMessage === http.OutgoingMessage && s.Server === http.Server, + unique: [...o.parseUniqueHeadersOption(["X-A", ["x-a", "X-B"]])], + none: o.parseUniqueHeadersOption(null), + target: { + requestTimeout: target.requestTimeout, + headersTimeout: target.headersTimeout, + requireHostHeader: target.requireHostHeader, + }, + errors, + closed, + }; + }, +}; diff --git a/src/compat/fs/embedded.ts b/src/compat/fs/embedded.ts new file mode 100644 index 00000000..d8136190 --- /dev/null +++ b/src/compat/fs/embedded.ts @@ -0,0 +1,298 @@ +// Read-only in-memory filesystem for bundled worker assets. Build +// integrations register file contents at startup; bundled server code such +// as OpenNext's traced manifests then reads them through the node:fs +// surface. Mutating calls and real device filesystem access are not +// provided. + +const encoder = new TextEncoder(); +const files = new Map(); + +function normalize(path: unknown): string { + if (typeof path !== "string") throw new TypeError("path must be a string"); + const raw = path.startsWith("file://") ? new URL(path).pathname : path; + const parts: string[] = []; + for (const segment of raw.split("/")) { + if (segment === "" || segment === ".") continue; + if (segment === "..") parts.pop(); + else parts.push(segment); + } + return "/" + parts.join("/"); +} + +/** Called by generated bundle code; consumers do not invoke this directly. */ +export function registerVirtualFiles( + entries: Record, +): void { + for (const [path, contents] of Object.entries(entries)) { + const key = normalize(path); + files.set( + key, + typeof contents === "string" + ? encoder.encode(contents) + : contents instanceof Uint8Array + ? new Uint8Array(contents) + : Uint8Array.from(atob(contents.base64), (c) => c.charCodeAt(0)), + ); + } +} +/** Test/reset helper. */ +export function clearVirtualFiles(): void { + files.clear(); +} + +function fileEntry(path: string): Uint8Array | undefined { + const direct = files.get(path); + if (direct !== undefined) return direct; + // Bundled runtimes resolve relative to an empty dirname; treat relative + // and absolute lookups uniformly, then fall back to a suffix match so a + // build-absolute path resolves against a registered relative one. + for (const [key, contents] of files) + if (key === path || key.endsWith(path) || path.endsWith(key)) + return contents; + return undefined; +} + +function dirEntries(path: string): string[] { + const prefix = path.endsWith("/") ? path : path + "/"; + const names = new Set(); + for (const key of files.keys()) { + if (!key.startsWith(prefix)) continue; + const rest = key.slice(prefix.length); + names.add(rest.split("/")[0]); + } + return [...names].sort(); +} + +function exists(path: string): boolean { + return fileEntry(path) !== undefined || dirEntries(path).length > 0; +} + +function enoent(syscall: string, path: string): Error { + const error = new Error( + `ENOENT: no such file or directory, ${syscall} '${path}'`, + ) as NodeJS.ErrnoException; + error.code = "ENOENT"; + error.errno = -2; + error.syscall = syscall; + error.path = path; + return error; +} + +export class Stats { + readonly #size: number; + readonly #directory: boolean; + readonly #mtime: Date; + constructor(size: number, directory: boolean, mtime: Date) { + this.#size = size; + this.#directory = directory; + this.#mtime = mtime; + } + isFile() { + return !this.#directory; + } + isDirectory() { + return this.#directory; + } + isSymbolicLink() { + return false; + } + isBlockDevice() { + return false; + } + isCharacterDevice() { + return false; + } + isFIFO() { + return false; + } + isSocket() { + return false; + } + get size() { + return this.#size; + } + get mtime() { + return this.#mtime; + } + get mtimeMs() { + return this.#mtime.getTime(); + } + get birthtime() { + return this.#mtime; + } + get birthtimeMs() { + return this.#mtime.getTime(); + } + get ctime() { + return this.#mtime; + } + get ctimeMs() { + return this.#mtime.getTime(); + } + get atime() { + return this.#mtime; + } + get atimeMs() { + return this.#mtime.getTime(); + } + get mode() { + return this.#directory ? 0o40755 : 0o100644; + } + get dev() { + return 0; + } + get ino() { + return 0; + } + get nlink() { + return 1; + } + get uid() { + return 0; + } + get gid() { + return 0; + } + get rdev() { + return 0; + } + get blksize() { + return 4096; + } + get blocks() { + return Math.ceil(this.#size / 512); + } +} + +function statFor(path: string, syscall: string): Stats { + const data = fileEntry(path); + if (data !== undefined) return new Stats(data.length, false, new Date(0)); + if (dirEntries(path).length > 0 || path === "/") + return new Stats(0, true, new Date(0)); + throw enoent(syscall, path); +} + +function toPath(input: unknown): string { + if (input instanceof URL) return normalize(input.href); + if (typeof input !== "string" && !(input instanceof String)) + throw new TypeError("path must be a string or URL"); + return normalize(String(input)); +} + +function decode(data: Uint8Array, encoding?: string | null): string { + if (encoding === "utf8" || encoding === "utf-8" || encoding == null) + return new TextDecoder().decode(data); + throw new Error(`Unsupported encoding '${encoding}'`); +} + +export function readFileSync(path: unknown, options?: unknown): unknown { + const p = toPath(path); + const data = fileEntry(p); + if (data === undefined) throw enoent("open", p); + const encoding = + typeof options === "string" + ? options + : (options as { encoding?: string } | undefined)?.encoding; + return encoding ? decode(data, encoding) : new Uint8Array(data); +} + +export function readFile( + path: unknown, + options: unknown, + callback?: (error: Error | null, data?: unknown) => void, +): void { + const cb = (typeof options === "function" ? options : callback) as + | ((error: Error | null, data?: unknown) => void) + | undefined; + const promise = Promise.resolve().then(() => readFileSync(path, options)); + if (cb) + promise.then( + (data) => cb(null, data), + (error) => cb(error), + ); +} + +export function readdirSync(path: unknown): string[] { + const p = toPath(path); + const entries = dirEntries(p); + if (entries.length === 0 && fileEntry(p) === undefined && p !== "/") + throw enoent("scandir", p); + return entries; +} + +export function readdir( + path: unknown, + callback: (error: Error | null, entries?: string[]) => void, +): void { + Promise.resolve() + .then(() => readdirSync(path)) + .then( + (entries) => callback(null, entries), + (error) => callback(error), + ); +} + +export function existsSync(path: unknown): boolean { + return exists(toPath(path)); +} + +export function statSync(path: unknown): Stats { + return statFor(toPath(path), "stat"); +} + +export function lstatSync(path: unknown): Stats { + return statSync(path); +} + +export function stat( + path: unknown, + callback: (error: Error | null, stats?: Stats) => void, +): void { + Promise.resolve() + .then(() => statSync(path)) + .then( + (stats) => callback(null, stats), + (error) => callback(error), + ); +} + +export function realpathSync(path: unknown): string { + const p = toPath(path); + if (!exists(p)) throw enoent("realpath", p); + return p; +} + +export const promises = { + readFile: (path: unknown, options?: unknown) => + Promise.resolve().then(() => readFileSync(path, options)), + readdir: (path: unknown) => Promise.resolve().then(() => readdirSync(path)), + stat: (path: unknown) => Promise.resolve().then(() => statSync(path)), + lstat: (path: unknown) => Promise.resolve().then(() => lstatSync(path)), + realpath: (path: unknown) => Promise.resolve().then(() => realpathSync(path)), + access: (path: unknown) => + Promise.resolve().then(() => { + if (!exists(toPath(path))) throw enoent("access", toPath(path)); + }), +}; + +export const constants = { + F_OK: 0, + R_OK: 4, + W_OK: 2, + X_OK: 1, +}; + +export default { + readFileSync, + readFile, + readdirSync, + readdir, + existsSync, + statSync, + lstatSync, + stat, + realpathSync, + promises, + constants, + Stats, +}; diff --git a/src/compat/fs/index.ts b/src/compat/fs/index.ts index bb99614a..0b02148a 100644 --- a/src/compat/fs/index.ts +++ b/src/compat/fs/index.ts @@ -1,298 +1,357 @@ -// Read-only in-memory filesystem for bundled worker assets. Build -// integrations register file contents at startup; bundled server code such -// as OpenNext's traced manifests then reads them through the node:fs -// surface. Mutating calls and real device filesystem access are not -// provided. - -const encoder = new TextEncoder(); -const files = new Map(); - -function normalize(path: unknown): string { - if (typeof path !== "string") throw new TypeError("path must be a string"); - const raw = path.startsWith("file://") ? new URL(path).pathname : path; - const parts: string[] = []; - for (const segment of raw.split("/")) { - if (segment === "" || segment === ".") continue; - if (segment === "..") parts.pop(); - else parts.push(segment); - } - return "/" + parts.join("/"); +import { fileMode } from "./mode.js"; +import { validateInteger } from "../crypto/validation.js"; +import * as embedded from "./embedded.js"; +import { + temporary, + temporaryPath, + clearTemporaryFiles, + writablePath, + pathOf, +} from "./writable.js"; +import { Buffer } from "node:buffer"; +import { + validateFunction, + validateObject, + validateBoolean, +} from "../net/validators.js"; +export const registerVirtualFiles = embedded.registerVirtualFiles; +export function clearVirtualFiles() { + embedded.clearVirtualFiles(); + clearTemporaryFiles(); } - -/** Called by generated bundle code; consumers do not invoke this directly. */ -export function registerVirtualFiles( - entries: Record, -): void { - for (const [path, contents] of Object.entries(entries)) { - const key = normalize(path); - files.set( - key, - typeof contents === "string" - ? encoder.encode(contents) - : contents instanceof Uint8Array - ? contents - : Uint8Array.from(atob(contents.base64), (c) => c.charCodeAt(0)), - ); - } +const reads = new Set([ + "readFileSync", + "readFile", + "readdirSync", + "readdir", + "statSync", + "stat", + "lstatSync", + "realpathSync", + "existsSync", +]); +const api: any = { ...temporary }; +for (const name of Object.keys(api)) + if (typeof api[name] === "function" && /^[a-z]/.test(name)) + api[name] = (...args: any[]) => temporary[name](...args); +for (const name of [ + "ReadStream", + "WriteStream", + "FileReadStream", + "FileWriteStream", +]) { + api[name] = new Proxy(api[name], { + construct(_target, args) { + args[0] = writablePath(args[0], name); + return Reflect.construct(temporary[name], args); + }, + }); } -/** Test/reset helper. */ -export function clearVirtualFiles(): void { - files.clear(); +for (const name of reads) { + const old = (embedded as any)[name]; + api[name] = (...args: any[]) => + temporaryPath(args[0]) ? temporary[name](...args) : old(...args); } - -function fileEntry(path: string): Uint8Array | undefined { - const direct = files.get(path); - if (direct !== undefined) return direct; - // Bundled runtimes resolve relative to an empty dirname; treat relative - // and absolute lookups uniformly, then fall back to a suffix match so a - // build-absolute path resolves against a registered relative one. - for (const [key, contents] of files) - if (key === path || key.endsWith(path) || path.endsWith(key)) - return contents; - return undefined; +for (const name of ["watch", "watchFile", "unwatchFile"]) + api[name] = () => { + throw Object.assign(new Error("The operation is not supported"), { + code: "ERR_UNSUPPORTED_OPERATION", + }); + }; +// Workers reports the byte count from these synchronous operations. +for (const name of ["writeFileSync", "appendFileSync"]) + api[name] = (...args: any[]) => { + temporary[name](...args); + const encoding = typeof args[2] === "string" ? args[2] : args[2]?.encoding; + return typeof args[1] === "string" + ? Buffer.byteLength(args[1], encoding) + : args[1].byteLength; + }; +const promises: any = { ...temporary.promises }; +for (const name of Object.keys(promises)) + if (typeof promises[name] === "function" && /^[a-z]/.test(name)) + promises[name] = (...args: any[]) => temporary.promises[name](...args); +for (const name of [ + "readFile", + "readdir", + "stat", + "lstat", + "realpath", + "access", +]) { + const old = (embedded.promises as any)[name]; + promises[name] = (...args: any[]) => + temporaryPath(args[0]) ? temporary.promises[name](...args) : old(...args); } - -function dirEntries(path: string): string[] { - const prefix = path.endsWith("/") ? path : path + "/"; - const names = new Set(); - for (const key of files.keys()) { - if (!key.startsWith(prefix)) continue; - const rest = key.slice(prefix.length); - names.add(rest.split("/")[0]); - } - return [...names].sort(); +// Keep all writes inside the memory volume, including FileHandle operations. +for (const name of [ + "appendFile", + "writeFile", + "mkdir", + "mkdtemp", + "rm", + "rmdir", + "unlink", + "truncate", + "utimes", + "lutimes", + "chmod", + "chown", + "lchmod", + "lchown", + "open", + "rename", + "copyFile", + "cp", + "link", + "symlink", +]) { + promises[name] = async (...args: any[]) => { + if (name === "symlink") { + return new Promise((resolve, reject) => + temporary.symlink(...args, (error: unknown) => + error ? reject(error) : resolve(undefined), + ), + ); + } + const indexes = ["rename", "copyFile", "cp", "link"].includes(name) + ? [0, 1] + : [0]; + for (const i of indexes) + if ( + typeof args[i] !== "object" || + args[i] instanceof URL || + Buffer.isBuffer(args[i]) + ) { + if (!temporaryPath(args[i])) + throw Object.assign(new Error("EROFS: read-only file system"), { + code: "EROFS", + }); + } + return temporary.promises[name](...args); + }; } - -function exists(path: string): boolean { - return fileEntry(path) !== undefined || dirEntries(path).length > 0; -} - -function enoent(syscall: string, path: string): Error { - const error = new Error( - `ENOENT: no such file or directory, ${syscall} '${path}'`, - ) as NodeJS.ErrnoException; - error.code = "ENOENT"; - error.errno = -2; - error.syscall = syscall; - error.path = path; - return error; -} - -export class Stats { - readonly #size: number; - readonly #directory: boolean; - readonly #mtime: Date; - constructor(size: number, directory: boolean, mtime: Date) { - this.#size = size; - this.#directory = directory; - this.#mtime = mtime; - } - isFile() { - return !this.#directory; - } - isDirectory() { - return this.#directory; - } - isSymbolicLink() { - return false; - } - isBlockDevice() { - return false; - } - isCharacterDevice() { - return false; - } - isFIFO() { - return false; - } - isSocket() { - return false; - } - get size() { - return this.#size; - } - get mtime() { - return this.#mtime; - } - get mtimeMs() { - return this.#mtime.getTime(); - } - get birthtime() { - return this.#mtime; - } - get birthtimeMs() { - return this.#mtime.getTime(); - } - get ctime() { - return this.#mtime; - } - get ctimeMs() { - return this.#mtime.getTime(); - } - get atime() { - return this.#mtime; - } - get atimeMs() { - return this.#mtime.getTime(); - } - get mode() { - return this.#directory ? 0o40755 : 0o100644; - } - get dev() { - return 0; - } - get ino() { - return 0; - } - get nlink() { - return 1; - } - get uid() { - return 0; - } - get gid() { - return 0; - } - get rdev() { - return 0; - } - get blksize() { - return 4096; - } - get blocks() { - return Math.ceil(this.#size / 512); - } -} - -function statFor(path: string, syscall: string): Stats { - const data = fileEntry(path); - if (data !== undefined) return new Stats(data.length, false, new Date(0)); - if (dirEntries(path).length > 0 || path === "/") - return new Stats(0, true, new Date(0)); - throw enoent(syscall, path); -} - -function toPath(input: unknown): string { - if (input instanceof URL) return normalize(input.href); - if (typeof input !== "string" && !(input instanceof String)) - throw new TypeError("path must be a string or URL"); - return normalize(String(input)); -} - -function decode(data: Uint8Array, encoding?: string | null): string { - if (encoding === "utf8" || encoding === "utf-8" || encoding == null) - return new TextDecoder().decode(data); - throw new Error(`Unsupported encoding '${encoding}'`); -} - -export function readFileSync(path: unknown, options?: unknown): unknown { - const p = toPath(path); - const data = fileEntry(p); - if (data === undefined) throw enoent("open", p); - const encoding = - typeof options === "string" - ? options - : (options as { encoding?: string } | undefined)?.encoding; - return encoding ? decode(data, encoding) : data; -} - -export function readFile( - path: unknown, - options: unknown, - callback?: (error: Error | null, data?: unknown) => void, -): void { - const cb = (typeof options === "function" ? options : callback) as - | ((error: Error | null, data?: unknown) => void) - | undefined; - const promise = Promise.resolve().then(() => readFileSync(path, options)); - if (cb) - promise.then( - (data) => cb(null, data), - (error) => cb(error), - ); -} - -export function readdirSync(path: unknown): string[] { - const p = toPath(path); - const entries = dirEntries(p); - if (entries.length === 0 && fileEntry(p) === undefined && p !== "/") - throw enoent("scandir", p); - return entries; -} - -export function readdir( - path: unknown, - callback: (error: Error | null, entries?: string[]) => void, -): void { - Promise.resolve() - .then(() => readdirSync(path)) - .then( - (entries) => callback(null, entries), - (error) => callback(error), - ); -} - -export function existsSync(path: unknown): boolean { - return exists(toPath(path)); -} - -export function statSync(path: unknown): Stats { - return statFor(toPath(path), "stat"); -} - -export function lstatSync(path: unknown): Stats { - return statSync(path); +promises.watch = async function* () { + api.watch(); +}; +// Workers validates ownership/permission requests but has no mutable Unix +// ownership or permissions. These operations must not change the memory VFS. +function installOperation( + name: string, + handler: (...args: any[]) => any, + promise = true, +) { + api[name + "Sync"] = handler; + api[name] = (...args: any[]) => { + const callback = args.pop(); + validateFunction(callback, "callback"); + Promise.resolve() + .then(() => handler(...args)) + .then( + (value) => callback(null, value), + (error) => callback(error), + ); + }; + if (promise) promises[name] = async (...args: any[]) => handler(...args); } - -export function stat( - path: unknown, - callback: (error: Error | null, stats?: Stats) => void, -): void { - Promise.resolve() - .then(() => statSync(path)) - .then( - (stats) => callback(null, stats), - (error) => callback(error), - ); +function temporaryStats(stat: any) { + if (stat == null) return stat; + const bigint = typeof stat.mode === "bigint"; + const mode = (Number(stat.mode) & ~0o777) | 0o666; + stat.mode = bigint ? BigInt(mode) : mode; + stat.uid = stat.gid = bigint ? 0n : 0; + return stat; } - -export function realpathSync(path: unknown): string { - const p = toPath(path); - if (!exists(p)) throw enoent("realpath", p); - return p; +for (const name of ["stat", "lstat"]) + installOperation(name, (path: any, options?: any) => + temporaryPath(path) + ? temporaryStats(temporary[name + "Sync"](path, options)) + : embedded.statSync(path), + ); +installOperation( + "fstat", + (...args: any[]) => temporaryStats(temporary.fstatSync(...args)), + false, +); +for (const name of ["chmod", "lchmod", "fchmod", "chown", "lchown", "fchown"]) { + installOperation( + name, + (path: any, value: any, gid: any) => { + if (name.endsWith("chmod")) fileMode(value); + else { + validateInteger(value, "uid", -1, 0xffffffff); + validateInteger(gid, "gid", -1, 0xffffffff); + } + if (name.startsWith("f")) { + validateInteger(path, "fd", 0, 2147483647); + temporary.fstatSync(path); + } else if (name.startsWith("l") && temporaryPath(path)) + temporary.lstatSync(path); + else api.statSync(path); + }, + !name.startsWith("f"), + ); } - -export const promises = { - readFile: (path: unknown, options?: unknown) => - Promise.resolve().then(() => readFileSync(path, options)), - readdir: (path: unknown) => Promise.resolve().then(() => readdirSync(path)), - stat: (path: unknown) => Promise.resolve().then(() => statSync(path)), - lstat: (path: unknown) => Promise.resolve().then(() => lstatSync(path)), - realpath: (path: unknown) => Promise.resolve().then(() => realpathSync(path)), - access: (path: unknown) => - Promise.resolve().then(() => { - if (!exists(toPath(path))) throw enoent("access", toPath(path)); - }), -}; - -export const constants = { - F_OK: 0, - R_OK: 4, - W_OK: 2, - X_OK: 1, +installOperation("statfs", (path: any, options: any = {}) => { + pathOf(path); + validateObject(options, "options"); + const bigint = options.bigint ?? false; + validateBoolean(bigint, "options.bigint"); + const value = bigint ? 0n : 0; + return { + type: value, + bsize: value, + blocks: value, + bfree: value, + bavail: value, + files: value, + ffree: value, + }; +}); +const openPromise = promises.open; +promises.open = async (...args: any[]) => { + fileMode(args[2], 0o666); + args[2] = 0o666; + const handle = await openPromise(...args); + const stat = handle.stat.bind(handle); + handle.stat = async (...options: any[]) => + temporaryStats(await stat(...options)); + handle.chmod = async (mode: unknown) => { + fileMode(mode); + await stat(); + }; + handle.chown = async (uid: number, gid: number) => { + validateInteger(uid, "uid", -1, 0xffffffff); + validateInteger(gid, "gid", -1, 0xffffffff); + await stat(); + }; + return handle; }; - -export default { - readFileSync, - readFile, - readdirSync, - readdir, +// Copy an embedded bundle file into request-local /tmp without granting any +// write access to its source volume. +const temporaryCopyFile = api.copyFileSync; +installOperation("copyFile", (source: any, destination: any, mode = 0) => { + if (![0, 1, 2, 4].includes(mode)) + throw Object.assign(new TypeError("Invalid copy mode"), { + code: "ERR_INVALID_ARG_VALUE", + }); + if (mode === 4) + throw Object.assign(new Error("The operation is not supported"), { + code: "ERR_UNSUPPORTED_OPERATION", + }); + if (temporaryPath(source)) + return temporaryCopyFile(source, destination, mode); + writablePath(destination, "copyFile"); + if (mode === 1 && api.existsSync(destination)) + throw Object.assign(new Error("File already exists"), { code: "EEXIST" }); + temporary.writeFileSync(destination, embedded.readFileSync(pathOf(source))); +}); +api.promises = promises; +export { promises }; +export const { + Dir, + Dirent, + F_OK, + FileReadStream, + FileWriteStream, + R_OK, + ReadStream, + Stats, + W_OK, + WriteStream, + X_OK, + access, + accessSync, + appendFile, + appendFileSync, + chmod, + chmodSync, + chown, + chownSync, + close, + closeSync, + constants, + copyFile, + copyFileSync, + cp, + cpSync, + createReadStream, + createWriteStream, + exists, existsSync, - statSync, + fchmod, + fchmodSync, + fchown, + fchownSync, + fdatasync, + fdatasyncSync, + fstat, + fstatSync, + fsync, + fsyncSync, + ftruncate, + ftruncateSync, + futimes, + futimesSync, + glob, + globSync, + lchmod, + lchmodSync, + lchown, + lchownSync, + link, + linkSync, + lstat, lstatSync, - stat, + lutimes, + lutimesSync, + mkdir, + mkdirSync, + mkdtemp, + mkdtempSync, + open, + openAsBlob, + openSync, + opendir, + opendirSync, + read, + readFile, + readFileSync, + readSync, + readdir, + readdirSync, + readlink, + readlinkSync, + readv, + readvSync, + realpath, realpathSync, - promises, - constants, - Stats, -}; + rename, + renameSync, + rm, + rmSync, + rmdir, + rmdirSync, + stat, + statSync, + statfs, + statfsSync, + symlink, + symlinkSync, + truncate, + truncateSync, + unlink, + unlinkSync, + unwatchFile, + utimes, + utimesSync, + watch, + watchFile, + write, + writeFile, + writeFileSync, + writeSync, + writev, + writevSync, +} = api; +export default api; diff --git a/src/compat/fs/mode.ts b/src/compat/fs/mode.ts new file mode 100644 index 00000000..193ae03d --- /dev/null +++ b/src/compat/fs/mode.ts @@ -0,0 +1,17 @@ +// Pinned Workers mode validation (node/internal/validators.ts). +import { validateUint32 } from "../net/validators.js"; +import { ERR_INVALID_ARG_VALUE } from "../net/errors.js"; +export function fileMode(value: unknown, fallback?: number): number { + value ??= fallback; + if (typeof value === "string") { + if (!/^[0-7]+$/.test(value)) + throw new ERR_INVALID_ARG_VALUE( + "mode", + value, + "must be a 32-bit unsigned integer or an octal string", + ); + value = Number.parseInt(value, 8); + } + validateUint32(value, "mode"); + return value as number; +} diff --git a/src/compat/fs/promises/index.ts b/src/compat/fs/promises/index.ts index 8671d6b7..5e428b3b 100644 --- a/src/compat/fs/promises/index.ts +++ b/src/compat/fs/promises/index.ts @@ -1,3 +1,37 @@ import { promises } from "../index.js"; -export const { readFile, readdir, stat, lstat, realpath, access } = promises; +export const { + FileHandle, + access, + appendFile, + chmod, + chown, + constants, + copyFile, + cp, + glob, + lchmod, + lchown, + link, + lstat, + lutimes, + mkdir, + mkdtemp, + open, + opendir, + readFile, + readdir, + readlink, + realpath, + rename, + rm, + rmdir, + stat, + statfs, + symlink, + truncate, + unlink, + utimes, + watch, + writeFile, +} = promises; export default promises; diff --git a/src/compat/fs/writable.spec.ts b/src/compat/fs/writable.spec.ts new file mode 100644 index 00000000..a582c4dd --- /dev/null +++ b/src/compat/fs/writable.spec.ts @@ -0,0 +1,129 @@ +import { expect, test } from "vitest"; +import * as fs from "./index.js"; +import { runWithTemporaryFiles } from "./writable.js"; + +test("temporary files are isolated between requests and from the fallback volume", () => { + fs.clearVirtualFiles(); + runWithTemporaryFiles(() => { + fs.mkdirSync("/tmp/request"); + fs.writeFileSync("/tmp/request/data", "one"); + expect(fs.readFileSync("/tmp/request/data", "utf8")).toBe("one"); + runWithTemporaryFiles(() => { + expect(fs.existsSync("/tmp/request/data")).toBe(false); + fs.writeFileSync("/tmp/data", "two"); + }); + expect(fs.existsSync("/tmp/data")).toBe(false); + expect(fs.readFileSync("/tmp/request/data", "utf8")).toBe("one"); + }); + expect(fs.existsSync("/tmp/request/data")).toBe(false); +}); + +test("concurrent asynchronous requests retain separate temporary files", () => { + const operation = (value: string) => + runWithTemporaryFiles(() => { + fs.writeFileSync("/tmp/data", value); + return fs.promises.readFile("/tmp/data", "utf8").then((read: string) => { + expect(read).toBe(value); + expect(fs.readFileSync("/tmp/data", "utf8")).toBe(value); + }); + }); + return Promise.all([operation("first"), operation("second")]); +}); + +test("a temporary symlink cannot mutate embedded assets", () => { + fs.registerVirtualFiles({ "/bundle/secret": "original" }); + expect(() => fs.symlinkSync("/bundle/secret", "/tmp/link")).toThrow(); + expect(() => fs.writeFileSync("/bundle/secret", "changed")).toThrow(); + expect(fs.readFileSync("/bundle/secret", "utf8")).toBe("original"); +}); + +test("relative temporary symlinks resolve against their parent directory", async () => { + await runWithTemporaryFiles(async () => { + fs.mkdirSync("/tmp/nested"); + fs.writeFileSync("/tmp/nested/data", "local"); + fs.symlinkSync("data", "/tmp/nested/link"); + expect(fs.readFileSync("/tmp/nested/link", "utf8")).toBe("local"); + await fs.promises.symlink("../nested/data", "/tmp/nested/async-link"); + expect(await fs.promises.readFile("/tmp/nested/async-link", "utf8")).toBe( + "local", + ); + expect(() => + fs.symlinkSync("../../bundle/secret", "/tmp/nested/escape"), + ).toThrow(); + }); +}); + +test("callback writes report read-only paths asynchronously", async () => { + let returned = false; + const done = new Promise((resolve, reject) => { + fs.writeFile("/bundle/secret", "changed", (error: any) => { + try { + expect(returned).toBe(true); + expect(error.code).toBe("EROFS"); + resolve(); + } catch (failure) { + reject(failure); + } + }); + }); + returned = true; + await done; +}); + +test("direct stream constructors use the active request volume", async () => { + fs.clearVirtualFiles(); + const read = (value: string) => + runWithTemporaryFiles(() => { + fs.writeFileSync("/tmp/stream", value); + const stream = new fs.ReadStream("/tmp/stream"); + return new Promise((resolve, reject) => { + let text = ""; + stream.on("data", (chunk: any) => { + text += chunk.toString(); + }); + stream.on("end", () => resolve(text)); + stream.on("error", reject); + }); + }); + expect(await Promise.all([read("first"), read("second")])).toEqual([ + "first", + "second", + ]); + expect(fs.existsSync("/tmp/stream")).toBe(false); +}); + +test("embedded files can be copied into temporary files without exposing mutable storage", async () => { + fs.registerVirtualFiles({ "/bundle/copy-source": "original" }); + const bytes = fs.readFileSync("/bundle/copy-source") as Uint8Array; + bytes.fill(0); + expect(fs.readFileSync("/bundle/copy-source", "utf8")).toBe("original"); + await runWithTemporaryFiles(async () => { + await fs.promises.copyFile("/bundle/copy-source", "/tmp/copy"); + expect(fs.readFileSync("/tmp/copy", "utf8")).toBe("original"); + fs.writeFileSync("/tmp/copy", "changed"); + expect(fs.readFileSync("/bundle/copy-source", "utf8")).toBe("original"); + }); +}); + +test("permission operations preserve file metadata and statfs is a Workers stub", async () => { + await runWithTemporaryFiles(async () => { + fs.writeFileSync("/tmp/data", "content"); + const before = fs.statSync("/tmp/data"); + fs.chmodSync("/tmp/data", 0); + await fs.promises.chown("/tmp/data", 123, 456); + const handle = await fs.promises.open("/tmp/data", "r+"); + await handle.chmod(0); + await handle.chown(123, 456); + await handle.close(); + const after = fs.statSync("/tmp/data"); + expect([after.mode, after.uid, after.gid]).toEqual([ + before.mode, + before.uid, + before.gid, + ]); + expect(fs.readFileSync("/tmp/data", "utf8")).toBe("content"); + expect( + Object.values(await fs.promises.statfs("/missing", { bigint: true })), + ).toEqual(Array(7).fill(0n)); + }); +}); diff --git a/src/compat/fs/writable.ts b/src/compat/fs/writable.ts new file mode 100644 index 00000000..a0db6b0f --- /dev/null +++ b/src/compat/fs/writable.ts @@ -0,0 +1,153 @@ +import { fileMode } from "./mode.js"; +import { registerRequestScope } from "../../shared/request-scope.js"; +// Writable, memory-only /tmp. Embedded bundle files remain read-only. +// This adapter does not expose the device filesystem. +import { Volume, createFsFromVolume } from "memfs"; +import { Buffer } from "node:buffer"; +import { posix } from "node:path"; +import { ERR_INVALID_ARG_TYPE } from "../net/errors.js"; +import { AsyncLocalStorage } from "../async-hooks/index.js"; +export function pathOf(value: any): string { + if (value instanceof URL) value = decodeURIComponent(value.pathname); + if (Buffer.isBuffer(value)) value = value.toString(); + if (typeof value !== "string") + throw new ERR_INVALID_ARG_TYPE("path", ["string", "Buffer", "URL"], value); + return posix.resolve("/bundle", value); +} +export function temporaryPath(value: any): boolean { + if (typeof value === "number") return true; + const path = pathOf(value); + return path === "/tmp" || path.startsWith("/tmp/"); +} +export function writablePath(value: any, syscall: string) { + if (typeof value === "number") return value; + const path = pathOf(value); + if (!(path === "/tmp" || path.startsWith("/tmp/"))) + throw Object.assign( + new Error(`EROFS: read-only file system, ${syscall} '${path}'`), + { code: "EROFS", errno: -30, syscall, path }, + ); + return path; +} + +function createTemporary() { + const volume = new Volume(); + volume.mkdirSync("/tmp"); + const fs = createFsFromVolume(volume) as any; + const mutating = new Set([ + "appendFile", + "writeFile", + "mkdir", + "mkdtemp", + "rm", + "rmdir", + "unlink", + "truncate", + "utimes", + "lutimes", + "chmod", + "chown", + "lchmod", + "lchown", + ]); + const api: any = {}; + for (const name of Object.keys(fs)) { + if (typeof fs[name] !== "function") { + api[name] = fs[name]; + continue; + } + if (/^[A-Z]/.test(name)) { + api[name] = fs[name]; + continue; + } + const base = name.replace(/Sync$/, ""); + api[name] = (...args: any[]) => { + try { + if ( + ["writeFile", "appendFile"].includes(base) && + typeof args[0] !== "number" + ) { + const opts = args[2]; + if (typeof opts === "object" && opts !== null) { + fileMode(opts.mode, 0o666); + args[2] = { ...opts, mode: 0o666 }; + } else if (typeof opts === "function") + args.splice(2, 0, { mode: 0o666 }); + else if (opts === undefined || typeof opts === "string") + args[2] = { + mode: 0o666, + ...(typeof opts === "string" ? { encoding: opts } : {}), + }; + } + if (base === "symlink") { + args[1] = writablePath(args[1], base); + const target = Buffer.isBuffer(args[0]) + ? args[0].toString() + : args[0]; + if (typeof target !== "string") + throw new ERR_INVALID_ARG_TYPE( + "target", + ["string", "Buffer"], + target, + ); + writablePath(posix.resolve(posix.dirname(args[1]), target), base); + } else if (["rename", "copyFile", "cp", "link"].includes(base)) { + args[0] = writablePath(args[0], base); + args[1] = writablePath(args[1], base); + } else if ( + mutating.has(base) || + base === "open" || + base === "createWriteStream" + ) + args[0] = writablePath(args[0], base); + else if ( + typeof args[0] === "string" || + args[0] instanceof URL || + Buffer.isBuffer(args[0]) + ) + args[0] = pathOf(args[0]); + } catch (error) { + const callback = args[args.length - 1]; + if (!name.endsWith("Sync") && typeof callback === "function") { + queueMicrotask(() => callback(error)); + return; + } + throw error; + } + return fs[name](...args); + }; + } + return { + api, + clear() { + for (const name of fs.readdirSync("/tmp")) + fs.rmSync(`/tmp/${name}`, { recursive: true, force: true }); + }, + }; +} + +const contexts = new AsyncLocalStorage>(); +const fallback = createTemporary(); +const active = () => contexts.getStore() ?? fallback; +export const temporary: any = new Proxy( + {}, + { + get(_target, name) { + return active().api[name]; + }, + ownKeys() { + return Reflect.ownKeys(fallback.api); + }, + getOwnPropertyDescriptor() { + return { enumerable: true, configurable: true }; + }, + }, +); +export function clearTemporaryFiles() { + active().clear(); +} +export function runWithTemporaryFiles(callback: () => T): T { + return contexts.run(createTemporary(), callback); +} + +registerRequestScope(runWithTemporaryFiles); diff --git a/src/compat/http-common/index.ts b/src/compat/http-common/index.ts new file mode 100644 index 00000000..8d210733 --- /dev/null +++ b/src/compat/http-common/index.ts @@ -0,0 +1,48 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// Copyright Joyent and Node contributors. All rights reserved. MIT license. + +import { METHODS as methods } from "../http/index.js"; +import { kIncomingMessage } from "../http/symbols.js"; +export { methods, kIncomingMessage }; +const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/; +/** + * Verifies that the given val is a valid HTTP token + * per the rules defined in RFC 7230 + * See https://tools.ietf.org/html/rfc7230#section-3.2.6 + */ +export function _checkIsHttpToken(val: string): boolean { + return tokenRegExp.test(val); +} + +const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; +/** + * True if val contains an invalid field-vchar + * field-value = *( field-content / obs-fold ) + * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ] + * field-vchar = VCHAR / obs-text + */ +export function _checkInvalidHeaderChar( + val: number | string | ReadonlyArray, +): boolean { + if (Array.isArray(val)) { + return val.some((v: string) => headerCharRegex.test(v)); + } + return headerCharRegex.test(`${val}`); +} + +export const CRLF = "\r\n"; +export const chunkExpression = /(?:^|\W)chunked(?:$|\W)/i; +export const continueExpression = /(?:^|\W)100-continue(?:$|\W)/i; +export const parsers = { name: "parsers", max: 1000 }; +export default { + _checkIsHttpToken, + _checkInvalidHeaderChar, + chunkExpression, + kIncomingMessage, + CRLF, + continueExpression, + methods, + parsers, +}; diff --git a/src/compat/http-outgoing/index.ts b/src/compat/http-outgoing/index.ts new file mode 100644 index 00000000..65232d96 --- /dev/null +++ b/src/compat/http-outgoing/index.ts @@ -0,0 +1,46 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// Copyright Joyent and Node contributors. All rights reserved. MIT license. + +import { + OutgoingMessage, + validateHeaderName, + validateHeaderValue, +} from "../http/index.js"; +import { kUniqueHeaders, kHighWaterMark } from "../http/symbols.js"; +export { + OutgoingMessage, + validateHeaderName, + validateHeaderValue, + kUniqueHeaders, + kHighWaterMark, +}; +export function parseUniqueHeadersOption( + headers?: (string | string[])[], +): Set | null { + if (!Array.isArray(headers)) { + return null; + } + + const unique = new Set(); + for (const header of headers) { + if (Array.isArray(header)) { + for (const h of header) { + unique.add(h.toLowerCase()); + } + } else { + unique.add(header.toLowerCase()); + } + } + return unique; +} + +export default { + OutgoingMessage, + validateHeaderName, + validateHeaderValue, + kUniqueHeaders, + kHighWaterMark, + parseUniqueHeadersOption, +}; diff --git a/src/compat/http-server/index.ts b/src/compat/http-server/index.ts new file mode 100644 index 00000000..1321f3cf --- /dev/null +++ b/src/compat/http-server/index.ts @@ -0,0 +1,149 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// Copyright Joyent and Node contributors. All rights reserved. MIT license. + +import { + Server, + ServerResponse, + IncomingMessage, + STATUS_CODES, + _connectionListener, +} from "../http/index.js"; +import { + kIncomingMessage, + kServerResponse, + kConnectionsCheckingInterval, +} from "../http/symbols.js"; +import { validateInteger } from "../crypto/validation.js"; +import { validateBoolean } from "../net/validators.js"; +import { ERR_OUT_OF_RANGE } from "../net/errors.js"; +class ERR_OPTION_NOT_IMPLEMENTED extends Error { + code = "ERR_OPTION_NOT_IMPLEMENTED"; + constructor(option: string) { + super(`The ${option} option is not implemented`); + } +} +export { + Server, + ServerResponse, + STATUS_CODES, + kServerResponse, + kConnectionsCheckingInterval, + _connectionListener, +}; +export function setupConnectionsTracking(): never { + throw Object.assign( + new Error("The setupConnectionsTracking method is not implemented"), + { code: "ERR_METHOD_NOT_IMPLEMENTED" }, + ); +} +export function storeHTTPOptions(this: any, options: any): void { + this[kIncomingMessage] = options.IncomingMessage || IncomingMessage; + this[kServerResponse] = options.ServerResponse || ServerResponse; + + const maxHeaderSize = options.maxHeaderSize; + if (maxHeaderSize !== undefined) { + validateInteger(maxHeaderSize, "maxHeaderSize", 0); + throw new ERR_OPTION_NOT_IMPLEMENTED("maxHeaderSize"); + } + + const insecureHTTPParser = options.insecureHTTPParser; + if (insecureHTTPParser !== undefined) { + // If enabled it will use a HTTP parser with leniency flags enabled. + // Since our implementation does not use any http parser, and uses "fetch" API, + // it doesn't make sense to support this option. + validateBoolean(insecureHTTPParser, "options.insecureHTTPParser"); + } + + const requestTimeout = options.requestTimeout; + if (requestTimeout !== undefined) { + validateInteger(requestTimeout, "requestTimeout", 0); + this.requestTimeout = requestTimeout; + } else { + this.requestTimeout = 300_000; // 5 minutes + } + + const headersTimeout = options.headersTimeout; + if (headersTimeout !== undefined) { + validateInteger(headersTimeout, "headersTimeout", 0); + this.headersTimeout = headersTimeout; + } else { + this.headersTimeout = Math.min(60_000, this.requestTimeout); // Minimum between 60 seconds or requestTimeout + } + + if ( + this.requestTimeout > 0 && + this.headersTimeout > 0 && + this.headersTimeout > this.requestTimeout + ) { + throw new ERR_OUT_OF_RANGE( + "headersTimeout", + "<= requestTimeout", + headersTimeout, + ); + } + + const keepAliveTimeout = options.keepAliveTimeout; + if (keepAliveTimeout !== undefined) { + validateInteger(keepAliveTimeout, "keepAliveTimeout", 0); + throw new ERR_OPTION_NOT_IMPLEMENTED("keepAliveTimeout"); + } + + const keepAliveTimeoutBuffer = options.keepAliveTimeoutBuffer; + if (keepAliveTimeoutBuffer !== undefined) { + validateInteger(keepAliveTimeoutBuffer, "keepAliveTimeoutBuffer"); + throw new ERR_OPTION_NOT_IMPLEMENTED("keepAliveTimeoutBuffer"); + } + + const connectionsCheckingInterval = options.connectionsCheckingInterval; + if (connectionsCheckingInterval !== undefined) { + validateInteger( + connectionsCheckingInterval, + "connectionsCheckingInterval", + 0, + ); + throw new ERR_OPTION_NOT_IMPLEMENTED("connectionsCheckingInterval"); + } + + const requireHostHeader = options.requireHostHeader; + if (requireHostHeader !== undefined) { + validateBoolean(requireHostHeader, "options.requireHostHeader"); + this.requireHostHeader = requireHostHeader; + } else { + this.requireHostHeader = true; + } + + const joinDuplicateHeaders = options.joinDuplicateHeaders; + if (joinDuplicateHeaders !== undefined) { + validateBoolean(joinDuplicateHeaders, "options.joinDuplicateHeaders"); + } + this.joinDuplicateHeaders = joinDuplicateHeaders ?? false; + + const rejectNonStandardBodyWrites = options.rejectNonStandardBodyWrites; + if (rejectNonStandardBodyWrites !== undefined) { + validateBoolean( + rejectNonStandardBodyWrites, + "options.rejectNonStandardBodyWrites", + ); + this.rejectNonStandardBodyWrites = rejectNonStandardBodyWrites; + } else { + this.rejectNonStandardBodyWrites = false; + } +} + +export function httpServerPreClose(server: any) { + server.closeIdleConnections(); + clearInterval(server[kConnectionsCheckingInterval]); +} +export default { + Server, + ServerResponse, + STATUS_CODES, + kServerResponse, + kConnectionsCheckingInterval, + _connectionListener, + setupConnectionsTracking, + storeHTTPOptions, + httpServerPreClose, +}; diff --git a/src/compat/http/symbols.ts b/src/compat/http/symbols.ts new file mode 100644 index 00000000..182f7531 --- /dev/null +++ b/src/compat/http/symbols.ts @@ -0,0 +1,12 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// Copyright Joyent and Node contributors. All rights reserved. MIT license. + +export const kIncomingMessage = Symbol("IncomingMessage"); +export const kServerResponse = Symbol("ServerResponse"); +export const kUniqueHeaders = Symbol("kUniqueHeaders"); +export const kHighWaterMark = Symbol("kHighWaterMark"); +export const kConnectionsCheckingInterval = Symbol( + "http.server.connectionsCheckingInterval", +); diff --git a/src/compat/module/builtins.ts b/src/compat/module/builtins.ts new file mode 100644 index 00000000..f90e4dbf --- /dev/null +++ b/src/compat/module/builtins.ts @@ -0,0 +1,102 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// Intentionally does not include modules with mandatory 'node:' +// prefix like `node:test`. +// See: See https://nodejs.org/docs/latest/api/modules.html#built-in-modules-with-mandatory-node-prefix +// TODO(later): This list duplicates the list that is in +// workerd/jsg/modules.c++. Later we should source these +// from the same place so we don't have to maintain two lists. +export const builtinModules = [ + "_http_agent", + "_http_client", + "_http_common", + "_http_incoming", + "_http_outgoing", + "_http_server", + "_stream_duplex", + "_stream_passthrough", + "_stream_readable", + "_stream_transform", + "_stream_wrap", + "_stream_writable", + "_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", + "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", +]; +Object.freeze(builtinModules); diff --git a/src/compat/module/index.ts b/src/compat/module/index.ts index 588acc95..9770976a 100644 --- a/src/compat/module/index.ts +++ b/src/compat/module/index.ts @@ -2,29 +2,36 @@ // the registered virtual filesystem; executable modules cannot be loaded in // a bundled WebView runtime and throw explicitly. import { readFileSync } from "../fs/index.js"; -export const builtinModules = [ - "async_hooks", - "buffer", - "fs", - "fs/promises", - "http", - "module", - "net", - "path", - "querystring", - "stream", - "stream/web", - "string_decoder", - "util", -]; +import { builtinModules } from "./builtins.js"; +export { builtinModules }; +import * as metadata from "./metadata.js"; +export * from "./metadata.js"; +import { posix } from "node:path"; +import { ERR_INVALID_ARG_VALUE } from "../net/errors.js"; export function isBuiltin(specifier: string): boolean { + if (typeof specifier !== "string") return false; + if (["node:test", "node:test/reporters", "node:sqlite"].includes(specifier)) + return true; const name = specifier.startsWith("node:") ? specifier.slice(5) : specifier; return builtinModules.includes(name); } -export function createRequire(_filename: string | URL) { +export function createRequire(filename: string | URL) { + const value = String(filename); + if (!value.startsWith("/") && !value.startsWith("file:")) + throw new ERR_INVALID_ARG_VALUE( + "path", + value, + "The argument must be a file URL object, a file URL string, or an absolute path string.", + ); + const pathname = value.startsWith("file:") + ? decodeURIComponent(new URL(value).pathname) + : value; + const directory = posix.dirname(pathname); return function require(id: string): unknown { if (id.endsWith(".json")) { - const data = readFileSync(id, { encoding: "utf8" }); + const data = readFileSync(posix.resolve(directory, id), { + encoding: "utf8", + }); return JSON.parse(data as string); } throw new Error( @@ -43,4 +50,5 @@ export class Module { return createRequire("/")(id); } } +Object.assign(Module, metadata); export default Module; diff --git a/src/compat/module/metadata.ts b/src/compat/module/metadata.ts new file mode 100644 index 00000000..a9e4d61c --- /dev/null +++ b/src/compat/module/metadata.ts @@ -0,0 +1,154 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 + +// Pinned Workers module metadata and explicit stubs. +class ERR_METHOD_NOT_IMPLEMENTED extends Error { + readonly code = "ERR_METHOD_NOT_IMPLEMENTED"; + constructor(method: string) { + super(`The ${method} method is not implemented`); + } +} +export function register(): void { + // TODO(soon): We might support this in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.register"); +} + +export function runMain(): void { + // We don't plan to support this in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.runMain"); +} + +export function syncBuiltinESMExports(): void { + // We are unlikely to ever support this. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.syncBuiltinESMExports"); +} + +export function wrap(): void { + // TODO(soon): Implement this feature. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.wrap"); +} + +export const globalPaths: string[] = []; + +const compileCacheStatus = Object.freeze({ + __proto__: null, + FAILED: 0, + ENABLED: 1, + ALREADY_ENABLED: 2, + DISABLED: 3, +}); + +export const constants = Object.freeze({ + __proto__: null, + compileCacheStatus, +}); + +export const _cache = { __proto__: null }; +export const _pathCache = { __proto__: null }; + +export function _debug(): void { + // This is deprecated and will be removed in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._debug"); +} + +export function _findPath(): void { + // It doesn't make sense to support this. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._findPath"); +} + +export function _initPaths(): void { + // It doesn't make sense to support this. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._initPaths"); +} + +export function _load(): void { + // TODO(soon): Investigate the possibility of supporting this in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._load"); +} + +export function _preloadModules(): void { + // It doesn't make sense to support this. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._preloadModules"); +} + +export function _resolveFilename(): void { + // TODO(soon): Investigate the possibility of supporting this in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._resolveFilename"); +} + +export function _resolveLookupPaths(): void { + // TODO(soon): Investigate the possibility of supporting this in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._resolveLookupPaths"); +} + +export function _nodeModulePaths(): void { + // It doesn't make sense to support this. + throw new ERR_METHOD_NOT_IMPLEMENTED("module._nodeModulePaths"); +} + +export function findSourceMap(): void { + // TODO(soon): Investigate the possibility of supporting this in the future. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.findSourceMap"); +} + +export function findPackageJSON(): void { + // It doesn't make sense to support this. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.findPackageJSON"); +} + +export function flushCompileCache(): void { + // We don't implement compile cache. This acts as a no-op. +} + +export function getSourceMapsSupport(): Record { + return Object.freeze({ + __proto__: null, + enabled: false, + nodeModules: false, + generatedCode: false, + }); +} + +export function setSourceMapsSupport(): void { + // We don't implement source maps support. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.setSourceMapsSupport"); +} + +export function stripTypeScriptTypes(): void { + // We don't implement stripping TypeScript types. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.stripTypeScriptTypes"); +} + +export function registerHooks(): void { + // We don't implement hooks registration. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.registerHooks"); +} + +export function SourceMap(): void { + // We don't support source maps. + throw new ERR_METHOD_NOT_IMPLEMENTED("module.SourceMap"); +} + +export function enableCompileCache(): void { + // We don't plan to support this in the future. + // Since, this method shouldn't throw an error, we just act like a no-op. +} + +export function getCompileCacheDir(): undefined { + // We don't plan to support this in the future. + // Since, compile cache acts as a no-op, we just return undefined. + return undefined; +} + +export const _extensions = { + ".js": (): never => { + throw new ERR_METHOD_NOT_IMPLEMENTED("module._extensions.js"); + }, + ".json": (): never => { + throw new ERR_METHOD_NOT_IMPLEMENTED("module._extensions.json"); + }, + ".node": (): never => { + throw new ERR_METHOD_NOT_IMPLEMENTED("module._extensions.node"); + }, +}; diff --git a/src/compat/net/internal-net.ts b/src/compat/net/internal-net.ts index d8fee760..5a110a1f 100644 --- a/src/compat/net/internal-net.ts +++ b/src/compat/net/internal-net.ts @@ -1832,6 +1832,10 @@ function initializeConnection( allowHalfOpen: true, // A Node.js socket is always capable of being upgraded to the TLS socket. secureTransport: socket.encrypted ? "on" : "starttls", + expectedServerHostname: socket.encrypted + ? (socket as Socket & { servername?: string }).servername || + socket._host + : undefined, // We are not going to pass the high water-mark here. The outer Node.js // stream will implement the appropriate backpressure for us. }); diff --git a/src/compat/net/sockets.spec.ts b/src/compat/net/sockets.spec.ts index ea1063ec..5c6fef24 100644 --- a/src/compat/net/sockets.spec.ts +++ b/src/compat/net/sockets.spec.ts @@ -146,3 +146,24 @@ it("does not announce native EOF until the reader consumes buffered bytes", asyn call.mock.calls.filter((args) => args[1] === "socketRead"), ).toHaveLength(1); }); + +it("preserves the TLS verification name when connecting to a resolved address", async () => { + const call = vi.fn(async (_, method) => + method === "socketWatch" ? new Promise(() => {}) : {}, + ); + restore = setNativeCall(call); + const socket = connect("127.0.0.1:443", { + secureTransport: "on", + expectedServerHostname: "example.com", + }); + await socket.opened; + expect( + call.mock.calls.find((args) => args[1] === "socketOpen")?.[2], + ).toMatchObject({ + host: "127.0.0.1", + port: 443, + tls: true, + servername: "example.com", + }); + await socket.close(); +}); diff --git a/src/compat/net/sockets.ts b/src/compat/net/sockets.ts index 38fff192..cc4b4635 100644 --- a/src/compat/net/sockets.ts +++ b/src/compat/net/sockets.ts @@ -26,6 +26,7 @@ function encoded(value: Uint8Array) { export function connect( address: string, options: { + expectedServerHostname?: string; allowHalfOpen?: boolean; secureTransport?: "on" | "off" | "starttls"; } = {}, @@ -116,6 +117,9 @@ export function connect( host: url.hostname.replace(/^\[|\]$/g, ""), port, tls: options.secureTransport === "on", + ...(options.expectedServerHostname + ? { servername: options.expectedServerHostname } + : {}), }); }) .then(async (value) => { diff --git a/src/compat/process/base.d.ts b/src/compat/process/base.d.ts new file mode 100644 index 00000000..2c519113 --- /dev/null +++ b/src/compat/process/base.d.ts @@ -0,0 +1,38 @@ +declare module "cf-workers-native:process-base" { + const process: Record; + export default process; + export const addListener: any; + export const arch: any; + export const argv: any; + export const binding: any; + export const browser: any; + export const chdir: any; + export const cwd: any; + export const dlopen: any; + export const emit: any; + export const emitWarning: any; + export const env: any; + export const execArgv: any; + export const execPath: any; + export const exit: any; + export const features: any; + export const kill: any; + export const listeners: any; + export const memoryUsage: any; + export const nextTick: any; + export const off: any; + export const on: any; + export const once: any; + export const pid: any; + export const platform: any; + export const prependListener: any; + export const prependOnceListener: any; + export const removeAllListeners: any; + export const removeListener: any; + export const title: any; + export const umask: any; + export const uptime: any; + export const uvCounters: any; + export const version: any; + export const versions: any; +} diff --git a/src/compat/process/index.cjs b/src/compat/process/index.cjs new file mode 100644 index 00000000..7c72726b --- /dev/null +++ b/src/compat/process/index.cjs @@ -0,0 +1 @@ +module.exports = require("./index.js").default; diff --git a/src/compat/process/index.ts b/src/compat/process/index.ts new file mode 100644 index 00000000..63afd2e9 --- /dev/null +++ b/src/compat/process/index.ts @@ -0,0 +1,203 @@ +import * as metadata from "./metadata.js"; +export { + arch, + pid, + ppid, + allowedNodeEnvironmentFlags, + setSourceMapsEnabled, + getSourceMapsSupport, + ref, + unref, + setUncaughtExceptionCaptureCallback, + hasUncaughtExceptionCaptureCallback, + kill, + binding, + dlopen, + exitCode, + getActiveResourcesInfo, + memoryUsage, + resourceUsage, + threadCpuUsage, + cpuUsage, + channel, + connected, + debugPort, + noDeprecation, + traceDeprecation, + throwDeprecation, + sourceMapsEnabled, + execPath, + permission, + release, + report, + finalization, + _rawDebug, + moduleLoadList, + _preload_modules, + _linkedBinding, + domain, + _exiting, + _getActiveRequests, + _getActiveHandles, + _kill, + constrainedMemory, + availableMemory, + execve, + _fatalException, + _tickCallback, + _debugProcess, + _debugEnd, + _startProfilerIdleNotifier, + _stopProfilerIdleNotifier, + send, + uptime, + getegid, + getgid, + getgroups, + geteuid, + getuid, + setegid, + setgid, + seteuid, + setuid, + setgroups, + initgroups, +} from "./metadata.js"; +// Event delivery, warning and nextTick integration for the WebView profile. +// Other process exports retain the existing polyfill; see ../events/README.md. +export * from "cf-workers-native:process-base"; +import process from "./state.js"; +export { default } from "./state.js"; +import { EventEmitter } from "../events/index.js"; +import { ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } from "../net/errors.js"; +let initialized = false; +function invoke(method: string, args: any[]): any { + if (!initialized) { + EventEmitter.init.call(process as any); + initialized = true; + } + return Reflect.apply(EventEmitter.prototype[method], process, args); +} +export const on = (...args: any[]) => invoke("on", args); +export const addListener = on; +export const once = (...args: any[]) => invoke("once", args); +export const prependListener = (...args: any[]) => + invoke("prependListener", args); +export const prependOnceListener = (...args: any[]) => + invoke("prependOnceListener", args); +export const off = (...args: any[]) => invoke("off", args); +export const removeListener = off; +export const removeAllListeners = (...args: any[]) => + invoke("removeAllListeners", args); +export const emit = (...args: any[]) => invoke("emit", args); +export const listeners = (...args: any[]) => invoke("listeners", args); +const rawListeners = (...args: any[]) => invoke("rawListeners", args); +const eventNames = (...args: any[]) => invoke("eventNames", args); +const listenerCount = (...args: any[]) => invoke("listenerCount", args); +const getMaxListeners = (...args: any[]) => invoke("getMaxListeners", args); +const setMaxListeners = (...args: any[]) => invoke("setMaxListeners", args); +// Pinned workerd also implements nextTick with queueMicrotask. +export function nextTick(callback: (...args: any[]) => void, ...args: any[]) { + queueMicrotask(() => callback(...args)); +} +// Adapted from cloudflare/workerd@5358e3d337336eaf696a48bc1563d808b10feba5, +// src/node/internal/internal_process.ts, Apache-2.0. +// Copyright (c) 2017-2022 Cloudflare, Inc. +// https://opensource.org/licenses/Apache-2.0 +export function emitWarning( + warning: string | Error, + options?: any, + codeOrCtor?: any, + maybeCtor?: any, +) { + let err: Error & { code?: string; detail?: string }; + let name = "Warning", + detail, + code, + ctor; + if (typeof options === "object" && !Array.isArray(options)) { + if (options.type) name = options.type; + if (options.code) code = options.code; + if (options.detail) detail = options.detail; + ctor = options.ctor; + } else if (typeof options === "string") { + name = options; + if (typeof codeOrCtor === "string") { + code = codeOrCtor; + if (typeof maybeCtor === "function") ctor = maybeCtor; + else if (maybeCtor !== undefined) + throw new ERR_INVALID_ARG_TYPE("ctor", "function", maybeCtor); + } else if (typeof codeOrCtor === "function") ctor = codeOrCtor; + else if (codeOrCtor !== undefined) + throw new ERR_INVALID_ARG_TYPE("ctor", "function", codeOrCtor); + } else if (typeof options === "function") ctor = options; + else if (options !== undefined) + throw new ERR_INVALID_ARG_TYPE("options", "object", options); + if (typeof warning === "string") { + err = new (ctor || Error)(warning); + err.name = name; + } else if (warning instanceof Error) { + err = warning; + if (name && name !== "Warning") err.name = name; + } else throw new ERR_INVALID_ARG_TYPE("warning", "string or Error", warning); + if (code) err.code = code; + if (detail && typeof detail === "string") err.detail = detail; + // WebKit lacks V8's captureStackTrace. Exact stack inspection remains a + // process/engine acceptance gap even when warning delivery matches. + Error.captureStackTrace?.(err, ctor || emitWarning); + queueMicrotask(() => process.emit("warning", err)); +} +export const hrtime = Object.assign( + function hrtime(time?: [number, number]): [number, number] { + if (time !== undefined) { + if (!Array.isArray(time)) + throw new ERR_INVALID_ARG_TYPE("time", "tuple of integers", time); + else if ((time as number[]).length !== 2) + throw new ERR_OUT_OF_RANGE("time", "2", time); + } + const nanoTime = BigInt(Date.now()) * 1_000_000n; + const nanosBigint = nanoTime % 1_000_000_000n; + let seconds = Number((nanoTime - nanosBigint) / 1_000_000_000n); + let nanos = Number(nanosBigint); + if (time) { + const [prevSeconds, prevNanos] = time; + seconds -= prevSeconds; + nanos -= prevNanos; + // We don't have nanosecond-level precision, but if we + // did (say with the introduction of randomness), this + // is how we would handle nanosecond underflow + if (nanos < 0) { + seconds -= 1; + nanos += 1e9; + } + } + return [seconds, nanos]; + }, + { + bigint: function (): bigint { + return BigInt(Date.now()) * 1_000_000n; + }, + }, +); + +Object.assign(process, { + hrtime, + ...metadata, + on, + addListener, + once, + prependListener, + prependOnceListener, + off, + removeListener, + removeAllListeners, + emit, + listeners, + rawListeners, + eventNames, + listenerCount, + getMaxListeners, + setMaxListeners, + nextTick, + emitWarning, +}); diff --git a/src/compat/process/metadata.ts b/src/compat/process/metadata.ts new file mode 100644 index 00000000..8d3b1b72 --- /dev/null +++ b/src/compat/process/metadata.ts @@ -0,0 +1,357 @@ +// Copyright (c) 2017-2022 Cloudflare, Inc. Apache-2.0. +// Adapted from pinned workerd public_process.ts; these are Workers stubs, not host OS introspection. +import { NodeError } from "../net/error-base.js"; +class ERR_METHOD_NOT_IMPLEMENTED extends NodeError { + constructor(name: string) { + super( + "ERR_METHOD_NOT_IMPLEMENTED", + `The ${name} method is not implemented`, + ); + } +} +export class ERR_EPERM extends NodeError { + path?: string; + syscall: string; + errno: number; + constructor(options: { syscall: string; errno?: number; path?: string }) { + const message = options.path + ? `operation not permitted, ${options.syscall} '${options.path}'` + : "operation not permitted"; + super("EPERM", message); + this.syscall = options.syscall; + if (options.path !== undefined) { + this.path = options.path; + } + this.errno = options.errno ?? 1; // EPERM + } +} + +export const arch = "x64"; + +// For simplicity and polyfill expectations, we assign pid 1 to the process and pid 0 to the "parent". +export const pid = 1; +export const ppid = 0; + +export const allowedNodeEnvironmentFlags = new Set(); + +export function setSourceMapsEnabled( + _enabled: boolean, + _options?: { nodeModules: boolean; generatedCode: boolean }, +): void { + // no-op since we do not support disabling source maps +} + +export function getSourceMapsSupport(): { + enabled: boolean; + nodeModules: boolean; + generatedCode: boolean; +} { + return { + enabled: false, + nodeModules: false, + generatedCode: false, + }; +} + +export function ref(): void { + // no-op +} + +export function unref(): void { + // no-op +} + +export function setUncaughtExceptionCaptureCallback( + _fn?: (...args: unknown[]) => void, +): void { + throw new ERR_METHOD_NOT_IMPLEMENTED( + "process.setUncaughtExceptionCaptureCallback", + ); +} + +export function hasUncaughtExceptionCaptureCallback(): boolean { + throw new ERR_METHOD_NOT_IMPLEMENTED( + "process.hasUncaughtExceptionCaptureCallback", + ); +} + +export function kill(_pid: number, _signal?: string | number): boolean { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.kill"); +} + +export function binding(_name: string): unknown { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.binding"); +} + +export function dlopen( + _module: unknown, + _filename: string, + _flags?: number, +): void { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.dlopen"); +} + +export const exitCode: number | undefined = undefined; + +export function getActiveResourcesInfo(): string[] { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.getActiveResourcesInfo"); +} + +export function memoryUsage(): { + rss: number; + heapTotal: number; + heapUsed: number; + external: number; + arrayBuffers: number; +} { + return { + rss: 0, + heapTotal: 0, + heapUsed: 0, + external: 0, + arrayBuffers: 0, + }; +} + +export function resourceUsage(): { + userCPUTime: number; + systemCPUTime: number; + maxRSS: number; + sharedMemorySize: number; + unsharedDataSize: number; + unsharedStackSize: number; + minorPageFault: number; + majorPageFault: number; + swappedOut: number; + fsRead: number; + fsWrite: number; + ipcSent: number; + ipcReceived: number; + signalsCount: number; + voluntaryContextSwitches: number; + involuntaryContextSwitches: number; +} { + return { + userCPUTime: 0, + systemCPUTime: 0, + maxRSS: 0, + sharedMemorySize: 0, + unsharedDataSize: 0, + unsharedStackSize: 0, + minorPageFault: 0, + majorPageFault: 0, + swappedOut: 0, + fsRead: 0, + fsWrite: 0, + ipcSent: 0, + ipcReceived: 0, + signalsCount: 0, + voluntaryContextSwitches: 0, + involuntaryContextSwitches: 0, + }; +} + +export function threadCpuUsage(): { + user: number; + system: number; +} { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.threadCpuUsage"); +} + +export function cpuUsage(_previousValue?: { user: number; system: number }): { + user: number; + system: number; +} { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.cpuUsage"); +} + +// Properties and constants +export const channel = null; +export const connected = false; +export const debugPort = 0; // may be implemented to align with inspector in future +export const noDeprecation = false; +export const traceDeprecation = false; +export const throwDeprecation = false; +export const sourceMapsEnabled = false; +export const execPath = ""; + +export const permission = { + has: (): boolean => { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.permission.has"); + }, +}; + +export const release = { + name: "node", + lts: true, + sourceUrl: "", + headersUrl: "", +}; + +export const report = { + compact: false, + directory: "", + filename: "", + getReport: (): Record => { + // We do not intend to implement process.report in workerd, but there + // are some modules in the ecosystem that call it expecting it to exist and + // not throw. Returning an empty object for now to satisfy that use case. + return {}; + }, + reportOnFatalError: false, + reportOnSignal: false, + reportOnUncaughtException: false, + excludeNetwork: false, + excludeEnv: false, + signal: "SIGUSR2", + writeReport: (): string => { + // In this case, there's an expectation that the function will produce + // a report on disk and return the filename. Since we do not intend + // to implement this API in workerd, we throw to indicate that. + throw new ERR_METHOD_NOT_IMPLEMENTED("process.report.writeReport"); + }, +}; + +export const finalization = { + register: (): void => { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.finalization.register"); + }, + registerBeforeExit: (): void => { + throw new ERR_METHOD_NOT_IMPLEMENTED( + "process.finalization.registerBeforeExit", + ); + }, + unregister: (): void => { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.finalization.unregister"); + }, +}; + +// Additional undocumented APIs +export function _rawDebug(...args: unknown[]): void { + console.log(...args); +} + +export const moduleLoadList: string[] = []; +export const _preload_modules: string[] = []; + +export function _linkedBinding(_name: string): unknown { + throw new ERR_METHOD_NOT_IMPLEMENTED("process._linkedBinding"); +} + +export const domain = null; +export const _exiting = false; + +export function _getActiveRequests(): unknown[] { + return []; +} + +export function _getActiveHandles(): unknown[] { + return []; +} + +export function _kill(_pid: number, _signal: number): boolean { + throw new ERR_METHOD_NOT_IMPLEMENTED("process._kill"); +} + +export function constrainedMemory(): number { + return 0; +} + +export function availableMemory(): number { + // This may be implemented in future, for now this matches unenv + return 0; +} + +export function execve( + _file: string, + _args: string[], + _env: Record, +): never { + throw new ERR_METHOD_NOT_IMPLEMENTED("process.execve"); +} + +export function _fatalException(_err: Error): boolean { + return false; +} + +export function _tickCallback(): void { + // no-op +} + +export function _debugProcess(_pid: number): void { + // no-op +} + +export function _debugEnd(): void { + // no-op +} + +export function _startProfilerIdleNotifier(): void { + // no-op +} + +export function _stopProfilerIdleNotifier(): void { + // no-op +} + +export function send(_message: unknown, _sendHandle?: unknown): boolean { + return false; +} + +export function uptime(): number { + return 0; +} + +// On the virtual filesystem, we only support group 0 +export function getegid(): number { + return 0; +} + +export function getgid(): number { + return 0; +} + +export function getgroups(): number[] { + return [0]; +} + +// On the virtual filesystem, we only support user 0 +export function geteuid(): number { + return 0; +} + +export function getuid(): number { + return 0; +} + +// We support group 0 but no others, with the virtual filesystem. +export function setegid(id: number | string): void { + if (id !== 0) throw new ERR_EPERM({ syscall: "setegid" }); +} + +// We support group 0 but no others, with the virtual filesystem. +export function setgid(id: number | string): void { + if (id !== 0) throw new ERR_EPERM({ syscall: "setgid" }); +} + +// We support group 0 but no others, with the virtual filesystem. +export function seteuid(id: number | string): void { + if (id !== 0) throw new ERR_EPERM({ syscall: "seteuid" }); +} + +// We support group 0 but no others, with the virtual filesystem. +export function setuid(id: number | string): void { + if (id !== 0) throw new ERR_EPERM({ syscall: "setuid" }); +} + +// We don't support setting or initializing arbitrary groups on the virtual filesystem. +export function setgroups(_groups: number[]): void { + throw new ERR_EPERM({ syscall: "setgroups" }); +} + +export function initgroups( + _user: number | string, + _extractGroup: number | string, +): void { + throw new ERR_EPERM({ syscall: "initgroups" }); +} diff --git a/src/compat/process/state.ts b/src/compat/process/state.ts new file mode 100644 index 00000000..04139831 --- /dev/null +++ b/src/compat/process/state.ts @@ -0,0 +1,4 @@ +import original from "cf-workers-native:process-base"; +// A dependency leaf keeps process.env available during events/util cycles. +const process = { ...original }; +export default process; diff --git a/src/compat/stream-web/LICENSE b/src/compat/stream-web/LICENSE new file mode 100644 index 00000000..7adbcf57 --- /dev/null +++ b/src/compat/stream-web/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2026 Mattias Buelens +Copyright (c) 2016 Diwank Singh Tomer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/compat/stream-web/README.md b/src/compat/stream-web/README.md index 31c33607..82f79236 100644 --- a/src/compat/stream-web/README.md +++ b/src/compat/stream-web/README.md @@ -4,19 +4,25 @@ The public module and installed globals share their stream constructors. Stream callbacks capture the registered async context at construction; starting AsyncLocalStorage does not replace those constructor identities. -On hosts without readable byte streams (including iOS 26.1), the adapter uses -web-streams-polyfill 4.3.0 for the core stream family. Native compression and -encoding codecs are bridged with backpressure. Request/Response keep body -ownership in the JS stream, using the native body codecs after consumption. -Blob streams use the same family. The fallback is JavaScript only and is -installed/restored through the existing global ownership mechanism. +Every host uses the packaged web-streams-polyfill 4.3.0 implementation with +pinned Workers cancellation patches. Tee cancellation forwards the last branch's +reason. Abort during a pending pipeTo read waits for that read to settle, discards +the arriving chunk, and cancels the source before aborting the destination. +The differential profile covers default/byte tee and preventCancel/preventAbort. + +Native compression and encoding codecs are bridged with backpressure. +Request/Response keep body ownership in the JS stream, using native body codecs +after consumption. Pre-installation native Request bodies transfer through a +captured native TransformStream before bridging. Blob streams use the same +owned family. Global installation/restoration retains the ownership mechanism. The dependency is pinned because the body adapter reads its disturbance state. A missing or changed state fails explicitly. The fallback browser fixture -removes the host byte-stream APIs before module initialization in both the -page and Worker, and runs the regular runtime contracts unchanged. +removes the host byte-stream APIs before initialization in page and Worker, +and runs the regular runtime contracts unchanged. -Whole-module acceptance remains open. The pinned Workers tee cancellation -reason and pending pipeTo abort timing still differ from standard host/ponyfill -streams. Those are implementable differences recorded by the stream-boundary -experiment, not reasons to declare the module complete or technically impossible. +Rebuild the checked-in implementation with scripts/build-workers-streams.mjs. +The adjacent build manifest records the upstream revision, patched source hashes +and generated artifact hash. Raw-host boundary probes remain useful counterexamples +to host forwarding; they are not the adapter's acceptance tests. Whole-module +acceptance remains open beyond these verified operations. diff --git a/src/compat/stream-web/ponyfill.ts b/src/compat/stream-web/ponyfill.ts index c9d9c840..75bf72a0 100644 --- a/src/compat/stream-web/ponyfill.ts +++ b/src/compat/stream-web/ponyfill.ts @@ -1,3 +1,3 @@ // The build bundles this dependency into an owned ESM asset so raw browser // consumers do not need a package resolver or an import map. -export * from "web-streams-polyfill"; +export * from "./workers-ponyfill.js"; diff --git a/src/compat/stream-web/runtime.ts b/src/compat/stream-web/runtime.ts index b61913d8..d142481a 100644 --- a/src/compat/stream-web/runtime.ts +++ b/src/compat/stream-web/runtime.ts @@ -1,9 +1,9 @@ import { contextConstructor } from "./context.js"; import * as ponyfill from "./ponyfill.js"; import { nativeStreams } from "../../shared/globals/platform.js"; -// iOS 26.1 has default streams but no readable byte streams or BYOB readers. -export const usesPonyfill = - typeof nativeStreams.ReadableByteStreamController !== "function"; +// Use owned Streams on every host: native Streams differ from Workers +// in tee cancellation and pending pipeTo abort behavior. +export const usesPonyfill = true; export const ReadableStream: typeof globalThis.ReadableStream = contextConstructor( (usesPonyfill diff --git a/src/compat/stream-web/workers-ponyfill.build.json b/src/compat/stream-web/workers-ponyfill.build.json new file mode 100644 index 00000000..0e815e6f --- /dev/null +++ b/src/compat/stream-web/workers-ponyfill.build.json @@ -0,0 +1,8 @@ +{ + "revision": "12b4fedec6c01503a137d837204ca0b85992461e", + "changes": { + "pipe": "a8afacd41619c08bcd9237a57840473cd945a896c14bb5ac25f3bf57fb801944", + "tee": "1df4fe916895d4331ce3d9e35ba39e418616565e4bceae4ad1a8730f7c61cfe6" + }, + "sha256": "087a485b462ed99adf68d36ae114eacdc2a15f6fd28fb30ab9d95f52c3ca7a17" +} diff --git a/src/compat/stream-web/workers-ponyfill.d.ts b/src/compat/stream-web/workers-ponyfill.d.ts new file mode 100644 index 00000000..76253a5f --- /dev/null +++ b/src/compat/stream-web/workers-ponyfill.d.ts @@ -0,0 +1 @@ +export * from "web-streams-polyfill"; diff --git a/src/compat/stream-web/workers-ponyfill.js b/src/compat/stream-web/workers-ponyfill.js new file mode 100644 index 00000000..89eabab9 --- /dev/null +++ b/src/compat/stream-web/workers-ponyfill.js @@ -0,0 +1,3 @@ +// Generated from web-streams-polyfill 4.3.0 (MIT), with pinned Workers cancellation semantics. +// Rebuild using scripts/build-workers-streams.mjs; see LICENSE. +var yn=Object.defineProperty;var a=(e,r)=>yn(e,"name",{value:r,configurable:!0});function q(){}a(q,"noop");var pn=q,i=pn,Kr=q;function R(e){return typeof e=="object"&&e!==null||typeof e=="function"}a(R,"typeIsObject");var Xr=q;function y(e,r){try{Object.defineProperty(e,"name",{value:r,configurable:!0})}catch{}}a(y,"setFunctionName");var Zr=Promise,Sn=Promise.resolve.bind(Zr),Rn=Promise.prototype.then,hn=Promise.reject.bind(Zr),Re=Sn;function _(e){return new Zr(e)}a(_,"newPromise");function m(e){return _(r=>r(e))}a(m,"promiseResolvedWith");function u(e){return hn(e)}a(u,"promiseRejectedWith");function j(e,r,t){return Rn.call(e,r,t)}a(j,"PerformPromiseThen");function w(e,r,t){j(j(e,r,t),void 0,Xr)}a(w,"uponPromise");function Xe(e,r){w(e,r)}a(Xe,"uponFulfillment");function Ze(e,r){w(e,void 0,r)}a(Ze,"uponRejection");function L(e,r,t){return j(e,r,t)}a(L,"transformPromiseWith");function X(e){j(e,void 0,Xr)}a(X,"setPromiseIsHandledToTrue");var ye=a(e=>{if(typeof queueMicrotask=="function")ye=queueMicrotask;else{let r=m(void 0);ye=a(t=>j(r,t),"_queueMicrotask")}return ye(e)},"_queueMicrotask");function Z(e,r,t){if(typeof e!="function")throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,r,t)}a(Z,"reflectCall");function Q(e,r,t){i(typeof e=="function"),i(r!==void 0),i(Array.isArray(t));try{return m(Z(e,r,t))}catch(n){return u(n)}}a(Q,"promiseCall");var cr=16384,P=class{constructor(){this._cursor=0;this._size=0;this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}static{a(this,"SimpleQueue")}get length(){return this._size}push(r){let t=this._back,n=t;i(t._next===void 0),t._elements.length===cr-1&&(n={_elements:[],_next:void 0}),t._elements.push(r),n!==t&&(this._back=n,t._next=n),++this._size}shift(){i(this._size>0);let r=this._front,t=r,n=this._cursor,o=n+1,l=r._elements,s=l[n];return o===cr&&(i(l.length===cr),i(r._next!==void 0),t=r._next,o=0),--this._size,this._cursor=o,r!==t&&(this._front=t),l[n]=void 0,s}forEach(r){let t=this._cursor,n=this._front,o=n._elements;for(;(t!==o.length||n._next!==void 0)&&!(t===o.length&&(i(n._next!==void 0),i(t===cr),n=n._next,o=n._elements,t=0,o.length===0));)r(o[t]),++t}peek(){i(this._size>0);let r=this._front,t=this._cursor;return r._elements[t]}};var Jr=Symbol("[[AbortSteps]]"),et=Symbol("[[ErrorSteps]]"),je=Symbol("[[CancelSteps]]"),Fe=Symbol("[[PullSteps]]"),ze=Symbol("[[CanPullSyncSteps]]"),Ue=Symbol("[[ReleaseSteps]]");function br(e,r){e._ownerReadableStream=r,r._reader=e,r._state==="readable"?rt(e):r._state==="closed"?_n(e):(i(r._state==="errored"),Kt(e,r._storedError))}a(br,"ReadableStreamReaderGenericInitialize");function Le(e,r){let t=e._ownerReadableStream;return i(t!==void 0),z(t,r)}a(Le,"ReadableStreamReaderGenericCancel");function F(e){let r=e._ownerReadableStream;i(r!==void 0),i(r._reader===e),r._state==="readable"?yr(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):gn(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),r._readableStreamController[Ue](),r._reader=void 0,e._ownerReadableStream=void 0}a(F,"ReadableStreamReaderGenericRelease");function Qe(e){return new TypeError("Cannot "+e+" a stream using a released reader")}a(Qe,"readerLockException");function rt(e){e._closedPromise=_((r,t)=>{e._closedPromise_resolve=r,e._closedPromise_reject=t})}a(rt,"defaultReaderClosedPromiseInitialize");function Kt(e,r){rt(e),yr(e,r)}a(Kt,"defaultReaderClosedPromiseInitializeAsRejected");function _n(e){rt(e),tt(e)}a(_n,"defaultReaderClosedPromiseInitializeAsResolved");function yr(e,r){e._closedPromise_reject!==void 0&&(X(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}a(yr,"defaultReaderClosedPromiseReject");function gn(e,r){i(e._closedPromise_resolve===void 0),i(e._closedPromise_reject===void 0),Kt(e,r)}a(gn,"defaultReaderClosedPromiseResetToRejected");function tt(e){e._closedPromise_resolve!==void 0&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}a(tt,"defaultReaderClosedPromiseResolve");var Cn=Number.isFinite||function(e){return typeof e=="number"&&isFinite(e)},at=Cn;var Tn=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)},Xt=Tn;function Pn(e){return typeof e=="object"||typeof e=="function"}a(Pn,"isDictionary");function v(e,r){if(e!==void 0&&!Pn(e))throw new TypeError(`${r} is not an object.`)}a(v,"assertDictionary");function k(e,r){if(typeof e!="function")throw new TypeError(`${r} is not a function.`)}a(k,"assertFunction");function wn(e){return typeof e=="object"&&e!==null||typeof e=="function"}a(wn,"isObject");function pr(e,r){if(!wn(e))throw new TypeError(`${r} is not an object.`)}a(pr,"assertObject");function I(e,r,t){if(e===void 0)throw new TypeError(`Parameter ${r} is required in '${t}'.`)}a(I,"assertRequiredArgument");function Je(e,r,t){if(e===void 0)throw new TypeError(`${r} is required in '${t}'.`)}a(Je,"assertRequiredField");function er(e){return Number(e)}a(er,"convertUnrestrictedDouble");function Zt(e){return e===0?0:e}a(Zt,"censorNegativeZero");function vn(e){return Zt(Xt(e))}a(vn,"integerPart");function Ve(e,r){let n=Number.MAX_SAFE_INTEGER,o=Number(e);if(o=Zt(o),!at(o))throw new TypeError(`${r} is not a finite number`);if(o=vn(o),o<0||o>n)throw new TypeError(`${r} is outside the accepted range of 0 to ${n}, inclusive`);return!at(o)||o===0?0:o}a(Ve,"convertUnsignedLongLongWithEnforceRange");function Me(e,r){if(!W(e))throw new TypeError(`${r} is not a ReadableStream.`)}a(Me,"assertReadableStream");function se(e){return new J(e)}a(se,"AcquireReadableStreamDefaultReader");function Rr(e,r){i(V(e._reader)),i(e._state==="readable"),e._reader._readRequests.push(r)}a(Rr,"ReadableStreamAddReadRequest");function rr(e,r,t){let n=e._reader;i(n._readRequests.length>0);let o=n._readRequests.shift();t?o._closeSteps():o._chunkSteps(r)}a(rr,"ReadableStreamFulfillReadRequest");function Te(e){return e._reader._readRequests.length}a(Te,"ReadableStreamGetNumReadRequests");function hr(e){let r=e._reader;return!(r===void 0||!V(r))}a(hr,"ReadableStreamHasDefaultReader");var J=class{static{a(this,"ReadableStreamDefaultReader")}constructor(r){if(I(r,1,"ReadableStreamDefaultReader"),Me(r,"First parameter"),D(r))throw new TypeError("This stream has already been locked for exclusive reading by another reader");br(this,r),this._readRequests=new P}get closed(){return V(this)?this._closedPromise:u(Sr("closed"))}cancel(r=void 0){return V(this)?this._ownerReadableStream===void 0?u(Qe("cancel")):Le(this,r):u(Sr("cancel"))}read(){if(!V(this))return u(Sr("read"));if(this._ownerReadableStream===void 0)return u(Qe("read from"));let r=it(this)?new ot:new nt;return pe(this,r),i(r._promise!==void 0),r._promise}releaseLock(){if(!V(this))throw Sr("releaseLock");this._ownerReadableStream!==void 0&&Bn(this)}};Object.defineProperties(J.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}});y(J.prototype.cancel,"cancel");y(J.prototype.read,"read");y(J.prototype.releaseLock,"releaseLock");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(J.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});var nt=class{static{a(this,"DefaultReadRequest")}constructor(){this._promise=_((r,t)=>{this._resolvePromise=r,this._rejectPromise=t})}_chunkSteps(r){this._resolvePromise({value:r,done:!1})}_closeSteps(){this._resolvePromise({value:void 0,done:!0})}_errorSteps(r){this._rejectPromise(r)}},ot=class{constructor(){this._promise=void 0}static{a(this,"SyncDefaultReadRequest")}_chunkSteps(r){i(this._promise===void 0),this._promise=Re({value:r,done:!1})}_closeSteps(){i(this._promise===void 0),this._promise=Re({value:void 0,done:!0})}_errorSteps(r){i(this._promise===void 0),this._promise=u(r)}};function V(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_readRequests")?!1:e instanceof J}a(V,"IsReadableStreamDefaultReader");function pe(e,r){let t=e._ownerReadableStream;i(t!==void 0),t._disturbed=!0,t._state==="closed"?r._closeSteps():t._state==="errored"?r._errorSteps(t._storedError):(i(t._state==="readable"),t._readableStreamController[Fe](r))}a(pe,"ReadableStreamDefaultReaderRead");function it(e){let r=e._ownerReadableStream;return i(r!==void 0),r._state==="closed"||r._state==="errored"?!0:(i(r._state==="readable"),r._readableStreamController[ze]())}a(it,"ReadableStreamDefaultReaderCanReadSync");function Bn(e){F(e);let r=new TypeError("Reader was released");lt(e,r)}a(Bn,"ReadableStreamDefaultReaderRelease");function lt(e,r){let t=e._readRequests;e._readRequests=new P,t.forEach(n=>{n._errorSteps(r)})}a(lt,"ReadableStreamDefaultReaderErrorReadRequests");function Sr(e){return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`)}a(Sr,"defaultReaderBrandCheckException");function ea(e){return e.slice()}a(ea,"CreateArrayFromList");function ra(e,r,t,n,o){return e!==t&&!O(e)&&!O(t)&&r+o<=e.byteLength&&n+o<=t.byteLength}a(ra,"CanCopyDataBlockBytes");function st(e,r,t,n,o){new Uint8Array(e).set(new Uint8Array(t,n,o),r)}a(st,"CopyDataBlockBytes");var ue=a(e=>(typeof e.transfer=="function"?ue=a(r=>r.transfer(),"TransferArrayBuffer"):typeof structuredClone=="function"?ue=a(r=>structuredClone(r,{transfer:[r]}),"TransferArrayBuffer"):ue=a(r=>r,"TransferArrayBuffer"),ue(e)),"TransferArrayBuffer");function ta(e){return!O(e)}a(ta,"CanTransferArrayBuffer");var O=a(e=>(typeof e.detached=="boolean"?O=a(r=>r.detached,"IsDetachedBuffer"):O=a(r=>r.byteLength===0,"IsDetachedBuffer"),O(e)),"IsDetachedBuffer");function _r(e,r,t){if(e.slice)return e.slice(r,t);let n=t-r,o=new ArrayBuffer(n);return st(o,0,e,r,n),o}a(_r,"ArrayBufferSlice");function Ne(e,r){let t=e[r];if(t!=null){if(typeof t!="function")throw new TypeError(`${String(r)} is not a function`);return t}}a(Ne,"GetMethod");function An(e){let r={next(){let n;try{n=dt(e)}catch(o){return u(o)}return Jt(n)},return(n){let o;try{let l=Ne(e.iterator,"return");if(l===void 0)return m({done:!0,value:n});o=Z(l,e.iterator,[n])}catch(l){return u(l)}return R(o)?Jt(o):u(new TypeError("The iterator.return() method must return an object"))}},t=r.next;return{iterator:r,nextMethod:t,done:!1}}a(An,"CreateAsyncFromSyncIterator");function Jt(e){try{let r=e.done,t=e.value,n=Re(t);return j(n,o=>({done:r,value:o}))}catch(r){return u(r)}}a(Jt,"AsyncFromSyncIteratorContinuation");var Pe=Symbol.asyncIterator??Symbol.for?.("Symbol.asyncIterator")??"@@asyncIterator";function ut(e,r="sync",t){if(i(r==="sync"||r==="async"),t===void 0)if(r==="async"){if(t=Ne(e,Pe),t===void 0){let l=Ne(e,Symbol.iterator),s=ut(e,"sync",l);return An(s)}}else t=Ne(e,Symbol.iterator);if(t===void 0)throw new TypeError("The object is not iterable");let n=Z(t,e,[]);if(!R(n))throw new TypeError("The iterator method must return an object");let o=n.next;return{iterator:n,nextMethod:o,done:!1}}a(ut,"GetIterator");function dt(e){let r=Z(e.nextMethod,e.iterator,[]);if(!R(r))throw new TypeError("The iterator.next() method must return an object");return r}a(dt,"IteratorNext");var gr=class{constructor(r,t){this._ongoingPromise=void 0;this._isFinished=!1;this._reader=r,this._preventCancel=t}static{a(this,"ReadableStreamAsyncIteratorImpl")}next(){let r=a(()=>this._nextSteps(),"nextSteps");return this._ongoingPromise=this._ongoingPromise?L(this._ongoingPromise,r,r):r(),this._ongoingPromise}return(r){let t=a(()=>this._returnSteps(r),"returnSteps");return this._ongoingPromise=this._ongoingPromise?L(this._ongoingPromise,t,t):t(),this._ongoingPromise}_nextSteps(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});let r=this._reader;i(r._ownerReadableStream!==void 0);let t=new ft(this);return pe(r,t),t._promise}_returnSteps(r){if(this._isFinished)return Promise.resolve({value:r,done:!0});this._isFinished=!0;let t=this._reader;if(i(t._ownerReadableStream!==void 0),i(t._readRequests.length===0),!this._preventCancel){let n=Le(t,r);return F(t),L(n,()=>({value:r,done:!0}))}return F(t),m({value:r,done:!0})}},ft=class{static{a(this,"AsyncIteratorReadRequest")}constructor(r){this._iterator=r,this._promise=_((t,n)=>{this._resolvePromise=t,this._rejectPromise=n})}_chunkSteps(r){let t=this._iterator;t._ongoingPromise=void 0,ye(()=>this._resolvePromise({value:r,done:!1}))}_closeSteps(){let r=this._iterator;r._ongoingPromise=void 0,r._isFinished=!0,F(r._reader),this._resolvePromise({value:void 0,done:!0})}_errorSteps(r){let t=this._iterator;t._ongoingPromise=void 0,t._isFinished=!0,F(t._reader),this._rejectPromise(r)}},oa={next(){return aa(this)?this._asyncIteratorImpl.next():u(na("next"))},return(e){return aa(this)?this._asyncIteratorImpl.return(e):u(na("return"))},[Pe](){return this}};Object.defineProperty(oa,Pe,{enumerable:!1});function ia(e,r){let t=se(e),n=new gr(t,r),o=Object.create(oa);return o._asyncIteratorImpl=n,o}a(ia,"AcquireReadableStreamAsyncIterator");function aa(e){if(!R(e)||!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof gr}catch{return!1}}a(aa,"IsReadableStreamAsyncIterator");function na(e){return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`)}a(na,"streamAsyncIteratorBrandCheckException");var Wn=Number.isNaN||function(e){return e!==e},Cr=Wn;function we(e){return!(typeof e!="number"||Cr(e)||e<0)}a(we,"IsNonNegativeNumber");function mt(e){let r=_r(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(r)}a(mt,"CloneAsUint8Array");function tr(e){i("_queue"in e&&"_queueTotalSize"in e),i(e._queue.length>0);let r=e._queue.shift();return e._queueTotalSize-=r.size,e._queueTotalSize<0&&(e._queueTotalSize=0),r.value}a(tr,"DequeueValue");function ar(e,r,t){if(i("_queue"in e&&"_queueTotalSize"in e),!we(t)||t===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");e._queue.push({value:r,size:t}),e._queueTotalSize+=t}a(ar,"EnqueueValueWithSize");function la(e){return i("_queue"in e&&"_queueTotalSize"in e),i(e._queue.length>0),e._queue.peek().value}a(la,"PeekQueueValue");function ee(e){i("_queue"in e&&"_queueTotalSize"in e),e._queue=new P,e._queueTotalSize=0}a(ee,"ResetQueue");var kn=Number.isInteger||function(e){return typeof e=="number"&&isFinite(e)&&Math.floor(e)===e},sa=kn;function ua(e){return e===DataView}a(ua,"isDataViewConstructor");function da(e){return ua(e.constructor)}a(da,"isDataView");function ct(e){return ua(e)?1:e.BYTES_PER_ELEMENT}a(ct,"arrayBufferViewElementSize");var de=class{static{a(this,"ReadableStreamBYOBRequest")}constructor(){throw new TypeError("Illegal constructor")}get view(){if(!bt(this))throw yt("view");return this._view}respond(r){if(!bt(this))throw yt("respond");if(I(r,1,"respond"),r=Ve(r,"First parameter"),this._associatedReadableByteStreamController===void 0)throw new TypeError("This BYOB request has been invalidated");if(O(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");i(this._view.byteLength>0),i(this._view.buffer.byteLength>0),ir(this._associatedReadableByteStreamController,r)}respondWithNewView(r){if(!bt(this))throw yt("respondWithNewView");if(I(r,1,"respondWithNewView"),!ArrayBuffer.isView(r))throw new TypeError("You can only respond with array buffer views");if(this._associatedReadableByteStreamController===void 0)throw new TypeError("This BYOB request has been invalidated");if(O(r.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");lr(this._associatedReadableByteStreamController,r)}};Object.defineProperties(de.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}});y(de.prototype.respond,"respond");y(de.prototype.respondWithNewView,"respondWithNewView");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(de.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var Y=class{static{a(this,"ReadableByteStreamController")}constructor(){throw new TypeError("Illegal constructor")}get byobRequest(){if(!re(this))throw nr("byobRequest");return vr(this)}get desiredSize(){if(!re(this))throw nr("desiredSize");return Ta(this)}close(){if(!re(this))throw nr("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");let r=this._controlledReadableByteStream._state;if(r!=="readable")throw new TypeError(`The stream (in ${r} state) is not in the readable state and cannot be closed`);$e(this)}enqueue(r){if(!re(this))throw nr("enqueue");if(I(r,1,"enqueue"),!ArrayBuffer.isView(r))throw new TypeError("chunk must be an array buffer view");if(r.byteLength===0)throw new TypeError("chunk must have non-zero byteLength");if(r.buffer.byteLength===0)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");let t=this._controlledReadableByteStream._state;if(t!=="readable")throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);or(this,r)}error(r=void 0){if(!re(this))throw nr("error");M(this,r)}[je](r){fa(this),ee(this);let t=this._cancelAlgorithm(r);return wr(this),t}[Fe](r){let t=this._controlledReadableByteStream;if(i(hr(t)),this._queueTotalSize>0){i(Te(t)===0),Ca(this,r);return}let n=this._autoAllocateChunkSize;if(n!==void 0){let o;try{o=new ArrayBuffer(n)}catch(s){r._errorSteps(s);return}let l={buffer:o,bufferByteLength:n,byteOffset:0,byteLength:n,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(l)}Rr(t,r),ve(this)}[ze](){return this._queueTotalSize>0}[Ue](){if(this._pendingPullIntos.length>0){let r=this._pendingPullIntos.peek();r.readerType="none",this._pendingPullIntos=new P,this._pendingPullIntos.push(r)}}};Object.defineProperties(Y.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}});y(Y.prototype.close,"close");y(Y.prototype.enqueue,"enqueue");y(Y.prototype.error,"error");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(Y.prototype,Symbol.toStringTag,{value:"ReadableByteStreamController",configurable:!0});function re(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")?!1:e instanceof Y}a(re,"IsReadableByteStreamController");function bt(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")?!1:e instanceof de}a(bt,"IsReadableStreamBYOBRequest");function ve(e){if(!Dn(e))return;if(e._pulling){e._pullAgain=!0;return}i(!e._pullAgain),e._pulling=!0;let t=e._pullAlgorithm();w(t,()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,ve(e)),null),n=>(M(e,n),null))}a(ve,"ReadableByteStreamControllerCallPullIfNeeded");function fa(e){Rt(e),e._pendingPullIntos=new P}a(fa,"ReadableByteStreamControllerClearPendingPullIntos");function ma(e,r){i(e._state!=="errored"),i(r.readerType!=="none");let t=!1;e._state==="closed"&&(i(r.bytesFilled%r.elementSize===0),t=!0);let n=ca(r);r.readerType==="default"?rr(e,n,t):(i(r.readerType==="byob"),wa(e,n,t))}a(ma,"ReadableByteStreamControllerCommitPullIntoDescriptor");function Pr(e,r){for(let t=0;t0&&ba(e,r.buffer,r.byteOffset,r.bytesFilled),Ye(e)}a(ya,"ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue");function pa(e,r){let t=Math.min(e._queueTotalSize,r.byteLength-r.bytesFilled),n=r.bytesFilled+t,o=t,l=!1;i(!O(r.buffer)),i(r.bytesFilled=r.minimumFill&&(o=d-r.bytesFilled,l=!0);let f=e._queue;for(;o>0;){let c=f.peek(),b=Math.min(o,c.byteLength),S=r.byteOffset+r.bytesFilled,h=r.buffer,E=c.buffer,oe=c.byteOffset;i(ra(h,S,E,oe,b)),st(h,S,E,oe,b),c.byteLength===b?f.shift():(c.byteOffset+=b,c.byteLength-=b),e._queueTotalSize-=b,Sa(e,b,r),o-=b}return l||(i(e._queueTotalSize===0),i(r.bytesFilled>0),i(r.bytesFilled0&&e._queueTotalSize!==0;){let t=e._pendingPullIntos.peek();i(t.readerType!=="none"),pa(e,t)&&(Ye(e),r.push(t))}return r}a(pt,"ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue");function In(e){let r=e._controlledReadableByteStream._reader;for(i(V(r));r._readRequests.length>0;){if(e._queueTotalSize===0)return;let t=r._readRequests.shift();Ca(e,t)}}a(In,"ReadableByteStreamControllerProcessReadRequestsUsingQueue");function ha(e,r,t,n){let o=e._controlledReadableByteStream,l=r.constructor,s=ct(l),{byteOffset:d,byteLength:f}=r,c=t*s;i(c>=s&&c<=f),i(c%s===0);let b;try{b=ue(r.buffer)}catch(h){n._errorSteps(h);return}let S={buffer:b,bufferByteLength:b.byteLength,byteOffset:d,byteLength:f,bytesFilled:0,minimumFill:c,elementSize:s,viewConstructor:l,readerType:"byob"};if(e._pendingPullIntos.length>0){e._pendingPullIntos.push(S),St(o,n);return}if(o._state==="closed"){let h=new l(S.buffer,S.byteOffset,0);n._closeSteps(h);return}if(e._queueTotalSize>0){if(pa(e,S)){let h=ca(S);Ra(e),n._chunkSteps(h);return}if(e._closeRequested){let h=new TypeError("Insufficient bytes to fill elements in the given buffer");M(e,h),n._errorSteps(h);return}}e._pendingPullIntos.push(S),St(o,n),ve(e)}a(ha,"ReadableByteStreamControllerPullInto");function _a(e,r,t){let n=e._controlledReadableByteStream,o=r.constructor,l=ct(o),{byteLength:s}=r,d=t*l;return i(d>=l&&d<=s),i(d%l===0),e._pendingPullIntos.length>0?!1:n._state==="closed"?!0:e._queueTotalSize>=d}a(_a,"ReadableByteStreamControllerCanPullIntoSync");function On(e,r){i(r.bytesFilled%r.elementSize===0),r.readerType==="none"&&Ye(e);let t=e._controlledReadableByteStream;if(Br(t)){let n=[];for(;n.length<_t(t);)n.push(Ye(e));Pr(t,n)}}a(On,"ReadableByteStreamControllerRespondInClosedState");function qn(e,r,t){if(i(t.bytesFilled+r<=t.byteLength),Sa(e,r,t),t.readerType==="none"){ya(e,t);let l=pt(e);Pr(e._controlledReadableByteStream,l);return}if(t.bytesFilled0){let l=t.byteOffset+t.bytesFilled;ba(e,t.buffer,l-n,n)}t.bytesFilled-=n;let o=pt(e);ma(e._controlledReadableByteStream,t),Pr(e._controlledReadableByteStream,o)}a(qn,"ReadableByteStreamControllerRespondInReadableState");function ga(e,r){let t=e._pendingPullIntos.peek();i(ta(t.buffer)),Rt(e);let n=e._controlledReadableByteStream._state;n==="closed"?(i(r===0),On(e,t)):(i(n==="readable"),i(r>0),qn(e,r,t)),ve(e)}a(ga,"ReadableByteStreamControllerRespondInternal");function Ye(e){return i(e._byobRequest===null),e._pendingPullIntos.shift()}a(Ye,"ReadableByteStreamControllerShiftPendingPullInto");function Dn(e){let r=e._controlledReadableByteStream;if(r._state!=="readable"||e._closeRequested||!e._started)return!1;if(hr(r)&&Te(r)>0||Br(r)&&_t(r)>0)return!0;let t=Ta(e);return i(t!==null),t>0}a(Dn,"ReadableByteStreamControllerShouldCallPull");function wr(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}a(wr,"ReadableByteStreamControllerClearAlgorithms");function $e(e){let r=e._controlledReadableByteStream;if(!(e._closeRequested||r._state!=="readable")){if(e._queueTotalSize>0){e._closeRequested=!0;return}if(e._pendingPullIntos.length>0){let t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){let n=new TypeError("Insufficient bytes to fill elements in the given buffer");throw M(e,n),n}}wr(e),Be(r)}}a($e,"ReadableByteStreamControllerClose");function or(e,r){let t=e._controlledReadableByteStream;if(e._closeRequested||t._state!=="readable")return;let{buffer:n,byteOffset:o,byteLength:l}=r;if(O(n))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");let s=ue(n);if(e._pendingPullIntos.length>0){let d=e._pendingPullIntos.peek();if(O(d.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Rt(e),d.buffer=ue(d.buffer),d.readerType==="none"&&ya(e,d)}if(hr(t))if(In(e),Te(t)===0)i(e._pendingPullIntos.length===0),Tr(e,s,o,l);else{i(e._queue.length===0),e._pendingPullIntos.length>0&&(i(e._pendingPullIntos.peek().readerType==="default"),Ye(e));let d=new Uint8Array(s,o,l);rr(t,d,!1)}else if(Br(t)){Tr(e,s,o,l);let d=pt(e);Pr(t,d)}else i(!D(t)),Tr(e,s,o,l);ve(e)}a(or,"ReadableByteStreamControllerEnqueue");function M(e,r){let t=e._controlledReadableByteStream;t._state==="readable"&&(fa(e),ee(e),wr(e),Ar(t,r))}a(M,"ReadableByteStreamControllerError");function Ca(e,r){i(e._queueTotalSize>0);let t=e._queue.shift();e._queueTotalSize-=t.byteLength,Ra(e);let n=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);r._chunkSteps(n)}a(Ca,"ReadableByteStreamControllerFillReadRequestFromQueue");function vr(e){if(e._byobRequest===null&&e._pendingPullIntos.length>0){let r=e._pendingPullIntos.peek(),t=new Uint8Array(r.buffer,r.byteOffset+r.bytesFilled,r.byteLength-r.bytesFilled),n=Object.create(de.prototype);En(n,e,t),e._byobRequest=n}return e._byobRequest}a(vr,"ReadableByteStreamControllerGetBYOBRequest");function Ta(e){let r=e._controlledReadableByteStream._state;return r==="errored"?null:r==="closed"?0:e._strategyHWM-e._queueTotalSize}a(Ta,"ReadableByteStreamControllerGetDesiredSize");function ir(e,r){i(e._pendingPullIntos.length>0);let t=e._pendingPullIntos.peek(),n=e._controlledReadableByteStream._state;if(n==="closed"){if(r!==0)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(i(n==="readable"),r===0)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(t.bytesFilled+r>t.byteLength)throw new RangeError("bytesWritten out of range")}t.buffer=ue(t.buffer),ga(e,r)}a(ir,"ReadableByteStreamControllerRespond");function lr(e,r){i(e._pendingPullIntos.length>0),i(!O(r.buffer));let t=e._pendingPullIntos.peek(),n=e._controlledReadableByteStream._state;if(n==="closed"){if(r.byteLength!==0)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(i(n==="readable"),r.byteLength===0)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(t.byteOffset+t.bytesFilled!==r.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(t.bufferByteLength!==r.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(t.bytesFilled+r.byteLength>t.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");let o=r.byteLength;t.buffer=ue(r.buffer),ga(e,o)}a(lr,"ReadableByteStreamControllerRespondWithNewView");function ht(e,r,t,n,o,l,s){i(e._readableStreamController===void 0),s!==void 0&&(i(sa(s)),i(s>0)),r._controlledReadableByteStream=e,r._pullAgain=!1,r._pulling=!1,r._byobRequest=null,r._queue=r._queueTotalSize=void 0,ee(r),r._closeRequested=!1,r._started=!1,r._strategyHWM=l,r._pullAlgorithm=n,r._cancelAlgorithm=o,r._autoAllocateChunkSize=s,r._pendingPullIntos=new P,e._readableStreamController=r;let d=t();w(m(d),()=>(r._started=!0,i(!r._pulling),i(!r._pullAgain),ve(r),null),f=>(M(r,f),null))}a(ht,"SetUpReadableByteStreamController");function Pa(e,r,t){let n=Object.create(Y.prototype),o,l,s;r.start!==void 0?o=a(()=>r.start(n),"startAlgorithm"):o=a(()=>{},"startAlgorithm"),r.pull!==void 0?l=a(()=>r.pull(n),"pullAlgorithm"):l=a(()=>m(void 0),"pullAlgorithm"),r.cancel!==void 0?s=a(f=>r.cancel(f),"cancelAlgorithm"):s=a(()=>m(void 0),"cancelAlgorithm");let d=r.autoAllocateChunkSize;if(d===0)throw new TypeError("autoAllocateChunkSize must be greater than 0");ht(e,n,o,l,s,t,d)}a(Pa,"SetUpReadableByteStreamControllerFromUnderlyingSource");function En(e,r,t){i(re(r)),i(typeof t=="object"),i(ArrayBuffer.isView(t)),i(!O(t.buffer)),e._associatedReadableByteStreamController=r,e._view=t}a(En,"SetUpReadableStreamBYOBRequest");function yt(e){return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`)}a(yt,"byobRequestBrandCheckException");function nr(e){return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`)}a(nr,"byteStreamControllerBrandCheckException");function va(e,r){v(e,r);let t=e?.mode;return{mode:t===void 0?void 0:xn(t,`${r} has member 'mode' that`)}}a(va,"convertReaderOptions");function xn(e,r){if(e=`${e}`,e!=="byob")throw new TypeError(`${r} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);return e}a(xn,"convertReadableStreamReaderMode");function Ba(e,r){v(e,r);let t=e?.min??1;return{min:Ve(t,`${r} has member 'min' that`)}}a(Ba,"convertByobReadOptions");function kr(e){return new ae(e)}a(kr,"AcquireReadableStreamBYOBReader");function St(e,r){i(te(e._reader)),i(e._state==="readable"||e._state==="closed"),e._reader._readIntoRequests.push(r)}a(St,"ReadableStreamAddReadIntoRequest");function wa(e,r,t){let n=e._reader;i(n._readIntoRequests.length>0);let o=n._readIntoRequests.shift();t?o._closeSteps(r):o._chunkSteps(r)}a(wa,"ReadableStreamFulfillReadIntoRequest");function _t(e){return e._reader._readIntoRequests.length}a(_t,"ReadableStreamGetNumReadIntoRequests");function Br(e){let r=e._reader;return!(r===void 0||!te(r))}a(Br,"ReadableStreamHasBYOBReader");var ae=class{static{a(this,"ReadableStreamBYOBReader")}constructor(r){if(I(r,1,"ReadableStreamBYOBReader"),Me(r,"First parameter"),D(r))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!re(r._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");br(this,r),this._readIntoRequests=new P}get closed(){return te(this)?this._closedPromise:u(Wr("closed"))}cancel(r=void 0){return te(this)?this._ownerReadableStream===void 0?u(Qe("cancel")):Le(this,r):u(Wr("cancel"))}read(r,t={}){if(!te(this))return u(Wr("read"));if(!ArrayBuffer.isView(r))return u(new TypeError("view must be an array buffer view"));if(r.byteLength===0)return u(new TypeError("view must have non-zero byteLength"));if(r.buffer.byteLength===0)return u(new TypeError("view's buffer must have non-zero byteLength"));if(O(r.buffer))return u(new TypeError("view's buffer has been detached"));let n;try{n=Ba(t,"options")}catch(s){return u(s)}let o=n.min;if(o===0)return u(new TypeError("options.min must be greater than 0"));if(da(r)){if(o>r.byteLength)return u(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>r.length)return u(new RangeError("options.min must be less than or equal to view's length"));if(this._ownerReadableStream===void 0)return u(Qe("read from"));let l=jn(this,r,o)?new Ct:new gt;return Tt(this,r,o,l),i(l._promise!==void 0),l._promise}releaseLock(){if(!te(this))throw Wr("releaseLock");this._ownerReadableStream!==void 0&&Fn(this)}};Object.defineProperties(ae.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}});y(ae.prototype.cancel,"cancel");y(ae.prototype.read,"read");y(ae.prototype.releaseLock,"releaseLock");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(ae.prototype,Symbol.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});var gt=class{static{a(this,"ByobReadIntoRequest")}constructor(){this._promise=_((r,t)=>{this._resolvePromise=r,this._rejectPromise=t})}_chunkSteps(r){this._resolvePromise({value:r,done:!1})}_closeSteps(r){this._resolvePromise({value:r,done:!0})}_errorSteps(r){this._rejectPromise(r)}},Ct=class{constructor(){this._promise=void 0}static{a(this,"SyncByobReadIntoRequest")}_chunkSteps(r){i(this._promise===void 0),this._promise=Re({value:r,done:!1})}_closeSteps(r){i(this._promise===void 0),this._promise=Re({value:r,done:!0})}_errorSteps(r){i(this._promise===void 0),this._promise=u(r)}};function te(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")?!1:e instanceof ae}a(te,"IsReadableStreamBYOBReader");function Tt(e,r,t,n){let o=e._ownerReadableStream;i(o!==void 0),o._disturbed=!0,o._state==="errored"?n._errorSteps(o._storedError):ha(o._readableStreamController,r,t,n)}a(Tt,"ReadableStreamBYOBReaderRead");function jn(e,r,t){let n=e._ownerReadableStream;return i(n!==void 0),n._state==="errored"?!0:_a(n._readableStreamController,r,t)}a(jn,"ReadableStreamBYOBReaderCanReadSync");function Fn(e){F(e);let r=new TypeError("Reader was released");Pt(e,r)}a(Fn,"ReadableStreamBYOBReaderRelease");function Pt(e,r){let t=e._readIntoRequests;e._readIntoRequests=new P,t.forEach(n=>{n._errorSteps(r)})}a(Pt,"ReadableStreamBYOBReaderErrorReadIntoRequests");function Wr(e){return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`)}a(Wr,"byobReaderBrandCheckException");function he(e,r){let{highWaterMark:t}=e;if(t===void 0)return r;if(Cr(t)||t<0)throw new RangeError("Invalid highWaterMark");return t}a(he,"ExtractHighWaterMark");function Ae(e){let{size:r}=e;return r||(()=>1)}a(Ae,"ExtractSizeAlgorithm");function We(e,r){v(e,r);let t=e?.highWaterMark,n=e?.size;return{highWaterMark:t===void 0?void 0:er(t),size:n===void 0?void 0:zn(n,`${r} has member 'size' that`)}}a(We,"convertQueuingStrategy");function zn(e,r){return k(e,r),t=>er(e(t))}a(zn,"convertQueuingStrategySize");function Aa(e,r){v(e,r);let t=e?.abort,n=e?.close,o=e?.start,l=e?.type,s=e?.write;return{abort:t===void 0?void 0:Un(t,e,`${r} has member 'abort' that`),close:n===void 0?void 0:Ln(n,e,`${r} has member 'close' that`),start:o===void 0?void 0:Qn(o,e,`${r} has member 'start' that`),write:s===void 0?void 0:Vn(s,e,`${r} has member 'write' that`),type:l}}a(Aa,"convertUnderlyingSink");function Un(e,r,t){return k(e,t),n=>Q(e,r,[n])}a(Un,"convertUnderlyingSinkAbortCallback");function Ln(e,r,t){return k(e,t),()=>Q(e,r,[])}a(Ln,"convertUnderlyingSinkCloseCallback");function Qn(e,r,t){return k(e,t),n=>Z(e,r,[n])}a(Qn,"convertUnderlyingSinkStartCallback");function Vn(e,r,t){return k(e,t),(n,o)=>Q(e,r,[n,o])}a(Vn,"convertUnderlyingSinkWriteCallback");function Ir(e,r){if(!$(e))throw new TypeError(`${r} is not a WritableStream.`)}a(Ir,"assertWritableStream");function Or(e){if(typeof e!="object"||e===null)return!1;try{return typeof e.aborted=="boolean"}catch{return!1}}a(Or,"isAbortSignal");function Wa(){if(typeof AbortController=="function")return new AbortController}a(Wa,"createAbortController");var me=class{static{a(this,"WritableStream")}constructor(r={},t={}){r===void 0?r=null:pr(r,"First parameter");let n=We(t,"Second parameter"),o=Aa(r,"First parameter");if(Oa(this),o.type!==void 0)throw new RangeError("Invalid type is specified");let s=Ae(n),d=he(n,1);eo(this,o,d,s)}get locked(){if(!$(this))throw Dr("locked");return fe(this)}abort(r=void 0){return $(this)?fe(this)?u(new TypeError("Cannot abort a stream that already has a writer")):ur(this,r):u(Dr("abort"))}close(){return $(this)?fe(this)?u(new TypeError("Cannot close a stream that already has a writer")):U(this)?u(new TypeError("Cannot close an already-closing stream")):qa(this):u(Dr("close"))}getWriter(){if(!$(this))throw Dr("getWriter");return At(this)}};Object.defineProperties(me.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}});y(me.prototype.abort,"abort");y(me.prototype.close,"close");y(me.prototype.getWriter,"getWriter");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(me.prototype,Symbol.toStringTag,{value:"WritableStream",configurable:!0});function At(e){return new ne(e)}a(At,"AcquireWritableStreamDefaultWriter");function Ia(e,r,t,n,o=1,l=()=>1){i(we(o));let s=Object.create(me.prototype);Oa(s);let d=Object.create(_e.prototype);return za(s,d,e,r,t,n,o,l),s}a(Ia,"CreateWritableStream");function Oa(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new P,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}a(Oa,"InitializeWritableStream");function $(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")?!1:e instanceof me}a($,"IsWritableStream");function fe(e){return i($(e)),e._writer!==void 0}a(fe,"IsWritableStreamLocked");function ur(e,r){if(e._state==="closed"||e._state==="errored")return m(void 0);e._writableStreamController._abortReason=r,e._writableStreamController._abortController?.abort(r);let t=e._state;if(t==="closed"||t==="errored")return m(void 0);if(e._pendingAbortRequest!==void 0)return e._pendingAbortRequest._promise;i(t==="writable"||t==="erroring");let n=!1;t==="erroring"&&(n=!0,r=void 0);let o=_((l,s)=>{e._pendingAbortRequest={_promise:void 0,_resolve:l,_reject:s,_reason:r,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=o,n||kt(e,r),o}a(ur,"WritableStreamAbort");function qa(e){let r=e._state;if(r==="closed"||r==="errored")return u(new TypeError(`The stream (in ${r} state) is not in the writable state and cannot be closed`));i(r==="writable"||r==="erroring"),i(!U(e));let t=_((o,l)=>{let s={_resolve:o,_reject:l};e._closeRequest=s}),n=e._writer;return n!==void 0&&e._backpressure&&r==="writable"&&xt(n),ro(e._writableStreamController),t}a(qa,"WritableStreamClose");function Mn(e){return i(fe(e)),i(e._state==="writable"),_((t,n)=>{let o={_resolve:t,_reject:n};e._writeRequests.push(o)})}a(Mn,"WritableStreamAddWriteRequest");function Wt(e,r){let t=e._state;if(t==="writable"){kt(e,r);return}i(t==="erroring"),It(e)}a(Wt,"WritableStreamDealWithRejection");function kt(e,r){i(e._storedError===void 0),i(e._state==="writable");let t=e._writableStreamController;i(t!==void 0),e._state="erroring",e._storedError=r;let n=e._writer;n!==void 0&&ja(n,r),!Da(e)&&t._started&&It(e)}a(kt,"WritableStreamStartErroring");function It(e){i(e._state==="erroring"),i(!Da(e)),e._state="errored",e._writableStreamController[et]();let r=e._storedError;if(e._writeRequests.forEach(o=>{o._reject(r)}),e._writeRequests=new P,e._pendingAbortRequest===void 0){qr(e);return}let t=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,t._wasAlreadyErroring){t._reject(r),qr(e);return}let n=e._writableStreamController[Jr](t._reason);w(n,()=>(t._resolve(),qr(e),null),o=>(t._reject(o),qr(e),null))}a(It,"WritableStreamFinishErroring");function Nn(e){i(e._inFlightWriteRequest!==void 0),e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}a(Nn,"WritableStreamFinishInFlightWrite");function Yn(e,r){i(e._inFlightWriteRequest!==void 0),e._inFlightWriteRequest._reject(r),e._inFlightWriteRequest=void 0,i(e._state==="writable"||e._state==="erroring"),Wt(e,r)}a(Yn,"WritableStreamFinishInFlightWriteWithError");function $n(e){i(e._inFlightCloseRequest!==void 0),e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0;let r=e._state;i(r==="writable"||r==="erroring"),r==="erroring"&&(e._storedError=void 0,e._pendingAbortRequest!==void 0&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";let t=e._writer;t!==void 0&&Va(t),i(e._pendingAbortRequest===void 0),i(e._storedError===void 0)}a($n,"WritableStreamFinishInFlightClose");function Gn(e,r){i(e._inFlightCloseRequest!==void 0),e._inFlightCloseRequest._reject(r),e._inFlightCloseRequest=void 0,i(e._state==="writable"||e._state==="erroring"),e._pendingAbortRequest!==void 0&&(e._pendingAbortRequest._reject(r),e._pendingAbortRequest=void 0),Wt(e,r)}a(Gn,"WritableStreamFinishInFlightCloseWithError");function U(e){return!(e._closeRequest===void 0&&e._inFlightCloseRequest===void 0)}a(U,"WritableStreamCloseQueuedOrInFlight");function Da(e){return!(e._inFlightWriteRequest===void 0&&e._inFlightCloseRequest===void 0)}a(Da,"WritableStreamHasOperationMarkedInFlight");function Hn(e){i(e._inFlightCloseRequest===void 0),i(e._closeRequest!==void 0),e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0}a(Hn,"WritableStreamMarkCloseRequestInFlight");function Kn(e){i(e._inFlightWriteRequest===void 0),i(e._writeRequests.length!==0),e._inFlightWriteRequest=e._writeRequests.shift()}a(Kn,"WritableStreamMarkFirstWriteRequestInFlight");function qr(e){i(e._state==="errored"),e._closeRequest!==void 0&&(i(e._inFlightCloseRequest===void 0),e._closeRequest._reject(e._storedError),e._closeRequest=void 0);let r=e._writer;r!==void 0&&Et(r,e._storedError)}a(qr,"WritableStreamRejectCloseAndClosedPromiseIfNeeded");function Ot(e,r){i(e._state==="writable"),i(!U(e));let t=e._writer;t!==void 0&&r!==e._backpressure&&(r?so(t):(i(!r),xt(t))),e._backpressure=r}a(Ot,"WritableStreamUpdateBackpressure");var ne=class{static{a(this,"WritableStreamDefaultWriter")}constructor(r){if(I(r,1,"WritableStreamDefaultWriter"),Ir(r,"First parameter"),fe(r))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=r,r._writer=this;let t=r._state;if(t==="writable")!U(r)&&r._backpressure?zr(this):ka(this),Er(this);else if(t==="erroring")Bt(this,r._storedError),Er(this);else if(t==="closed")ka(this),io(this);else{i(t==="errored");let n=r._storedError;Bt(this,n),Qa(this,n)}}get closed(){return ke(this)?this._closedPromise:u(Ie("closed"))}get desiredSize(){if(!ke(this))throw Ie("desiredSize");if(this._ownerWritableStream===void 0)throw sr("desiredSize");return Jn(this)}get ready(){return ke(this)?this._readyPromise:u(Ie("ready"))}abort(r=void 0){return ke(this)?this._ownerWritableStream===void 0?u(sr("abort")):Xn(this,r):u(Ie("abort"))}close(){if(!ke(this))return u(Ie("close"));let r=this._ownerWritableStream;return r===void 0?u(sr("close")):U(r)?u(new TypeError("Cannot close an already-closing stream")):Ea(this)}releaseLock(){if(!ke(this))throw Ie("releaseLock");let r=this._ownerWritableStream;r!==void 0&&(i(r._writer!==void 0),qt(this))}write(r=void 0){return ke(this)?this._ownerWritableStream===void 0?u(sr("write to")):xr(this,r):u(Ie("write"))}};Object.defineProperties(ne.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}});y(ne.prototype.abort,"abort");y(ne.prototype.close,"close");y(ne.prototype.releaseLock,"releaseLock");y(ne.prototype.write,"write");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(ne.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});function ke(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")?!1:e instanceof ne}a(ke,"IsWritableStreamDefaultWriter");function Xn(e,r){let t=e._ownerWritableStream;return i(t!==void 0),ur(t,r)}a(Xn,"WritableStreamDefaultWriterAbort");function Ea(e){let r=e._ownerWritableStream;return i(r!==void 0),qa(r)}a(Ea,"WritableStreamDefaultWriterClose");function xa(e){let r=e._ownerWritableStream;i(r!==void 0);let t=r._state;return U(r)||t==="closed"?m(void 0):t==="errored"?u(r._storedError):(i(t==="writable"||t==="erroring"),Ea(e))}a(xa,"WritableStreamDefaultWriterCloseWithErrorPropagation");function Zn(e,r){e._closedPromiseState==="pending"?Et(e,r):lo(e,r)}a(Zn,"WritableStreamDefaultWriterEnsureClosedPromiseRejected");function ja(e,r){e._readyPromiseState==="pending"?Ma(e,r):uo(e,r)}a(ja,"WritableStreamDefaultWriterEnsureReadyPromiseRejected");function Jn(e){let r=e._ownerWritableStream,t=r._state;return t==="errored"||t==="erroring"?null:t==="closed"?0:Ua(r._writableStreamController)}a(Jn,"WritableStreamDefaultWriterGetDesiredSize");function qt(e){let r=e._ownerWritableStream;i(r!==void 0),i(r._writer===e);let t=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");ja(e,t),Zn(e,t),r._writer=void 0,e._ownerWritableStream=void 0}a(qt,"WritableStreamDefaultWriterRelease");function xr(e,r){let t=e._ownerWritableStream;i(t!==void 0);let n=t._writableStreamController,o=to(n,r);if(t!==e._ownerWritableStream)return u(sr("write to"));let l=t._state;if(l==="errored")return u(t._storedError);if(U(t)||l==="closed")return u(new TypeError("The stream is closing or closed and cannot be written to"));if(l==="erroring")return u(t._storedError);i(l==="writable");let s=Mn(t);return ao(n,r,o),s}a(xr,"WritableStreamDefaultWriterWrite");var Fa={},_e=class{static{a(this,"WritableStreamDefaultController")}constructor(){throw new TypeError("Illegal constructor")}get abortReason(){if(!wt(this))throw vt("abortReason");return this._abortReason}get signal(){if(!wt(this))throw vt("signal");if(this._abortController===void 0)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal}error(r=void 0){if(!wt(this))throw vt("error");this._controlledWritableStream._state==="writable"&&La(this,r)}[Jr](r){let t=this._abortAlgorithm(r);return jr(this),t}[et](){ee(this)}};Object.defineProperties(_e.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}});typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(_e.prototype,Symbol.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});function wt(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")?!1:e instanceof _e}a(wt,"IsWritableStreamDefaultController");function za(e,r,t,n,o,l,s,d){i($(e)),i(e._writableStreamController===void 0),r._controlledWritableStream=e,e._writableStreamController=r,r._queue=void 0,r._queueTotalSize=void 0,ee(r),r._abortReason=void 0,r._abortController=Wa(),r._started=!1,r._strategySizeAlgorithm=d,r._strategyHWM=s,r._writeAlgorithm=n,r._closeAlgorithm=o,r._abortAlgorithm=l;let f=Dt(r);Ot(e,f);let c=t(),b=m(c);w(b,()=>(i(e._state==="writable"||e._state==="erroring"),r._started=!0,Fr(r),null),S=>(i(e._state==="writable"||e._state==="erroring"),r._started=!0,Wt(e,S),null))}a(za,"SetUpWritableStreamDefaultController");function eo(e,r,t,n){let o=Object.create(_e.prototype),l,s,d,f;r.start!==void 0?l=a(()=>r.start(o),"startAlgorithm"):l=a(()=>{},"startAlgorithm"),r.write!==void 0?s=a(c=>r.write(c,o),"writeAlgorithm"):s=a(()=>m(void 0),"writeAlgorithm"),r.close!==void 0?d=a(()=>r.close(),"closeAlgorithm"):d=a(()=>m(void 0),"closeAlgorithm"),r.abort!==void 0?f=a(c=>r.abort(c),"abortAlgorithm"):f=a(()=>m(void 0),"abortAlgorithm"),za(e,o,l,s,d,f,t,n)}a(eo,"SetUpWritableStreamDefaultControllerFromUnderlyingSink");function jr(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}a(jr,"WritableStreamDefaultControllerClearAlgorithms");function ro(e){ar(e,Fa,0),Fr(e)}a(ro,"WritableStreamDefaultControllerClose");function to(e,r){if(e._strategySizeAlgorithm===void 0)return i(e._controlledWritableStream._state!=="writable"),1;try{return e._strategySizeAlgorithm(r)}catch(t){return Ge(e,t),1}}a(to,"WritableStreamDefaultControllerGetChunkSize");function Ua(e){return e._strategyHWM-e._queueTotalSize}a(Ua,"WritableStreamDefaultControllerGetDesiredSize");function ao(e,r,t){try{ar(e,r,t)}catch(o){Ge(e,o);return}let n=e._controlledWritableStream;if(!U(n)&&n._state==="writable"){let o=Dt(e);Ot(n,o)}Fr(e)}a(ao,"WritableStreamDefaultControllerWrite");function Fr(e){let r=e._controlledWritableStream;if(!e._started||r._inFlightWriteRequest!==void 0)return;let t=r._state;if(i(t!=="closed"&&t!=="errored"),t==="erroring"){It(r);return}if(e._queue.length===0)return;let n=la(e);n===Fa?no(e):oo(e,n)}a(Fr,"WritableStreamDefaultControllerAdvanceQueueIfNeeded");function Ge(e,r){e._controlledWritableStream._state==="writable"&&La(e,r)}a(Ge,"WritableStreamDefaultControllerErrorIfNeeded");function no(e){let r=e._controlledWritableStream;Hn(r),tr(e),i(e._queue.length===0);let t=e._closeAlgorithm();jr(e),w(t,()=>($n(r),null),n=>(Gn(r,n),null))}a(no,"WritableStreamDefaultControllerProcessClose");function oo(e,r){let t=e._controlledWritableStream;Kn(t);let n=e._writeAlgorithm(r);w(n,()=>{Nn(t);let o=t._state;if(i(o==="writable"||o==="erroring"),tr(e),!U(t)&&o==="writable"){let l=Dt(e);Ot(t,l)}return Fr(e),null},o=>(t._state==="writable"&&jr(e),Yn(t,o),null))}a(oo,"WritableStreamDefaultControllerProcessWrite");function Dt(e){return Ua(e)<=0}a(Dt,"WritableStreamDefaultControllerGetBackpressure");function La(e,r){let t=e._controlledWritableStream;i(t._state==="writable"),jr(e),kt(t,r)}a(La,"WritableStreamDefaultControllerError");function Dr(e){return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`)}a(Dr,"streamBrandCheckException");function vt(e){return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`)}a(vt,"defaultControllerBrandCheckException");function Ie(e){return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`)}a(Ie,"defaultWriterBrandCheckException");function sr(e){return new TypeError("Cannot "+e+" a stream using a released writer")}a(sr,"defaultWriterLockException");function Er(e){e._closedPromise=_((r,t)=>{e._closedPromise_resolve=r,e._closedPromise_reject=t,e._closedPromiseState="pending"})}a(Er,"defaultWriterClosedPromiseInitialize");function Qa(e,r){Er(e),Et(e,r)}a(Qa,"defaultWriterClosedPromiseInitializeAsRejected");function io(e){Er(e),Va(e)}a(io,"defaultWriterClosedPromiseInitializeAsResolved");function Et(e,r){e._closedPromise_reject!==void 0&&(i(e._closedPromiseState==="pending"),X(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}a(Et,"defaultWriterClosedPromiseReject");function lo(e,r){i(e._closedPromise_resolve===void 0),i(e._closedPromise_reject===void 0),i(e._closedPromiseState!=="pending"),Qa(e,r)}a(lo,"defaultWriterClosedPromiseResetToRejected");function Va(e){e._closedPromise_resolve!==void 0&&(i(e._closedPromiseState==="pending"),e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}a(Va,"defaultWriterClosedPromiseResolve");function zr(e){e._readyPromise=_((r,t)=>{e._readyPromise_resolve=r,e._readyPromise_reject=t}),e._readyPromiseState="pending"}a(zr,"defaultWriterReadyPromiseInitialize");function Bt(e,r){zr(e),Ma(e,r)}a(Bt,"defaultWriterReadyPromiseInitializeAsRejected");function ka(e){zr(e),xt(e)}a(ka,"defaultWriterReadyPromiseInitializeAsResolved");function Ma(e,r){e._readyPromise_reject!==void 0&&(X(e._readyPromise),e._readyPromise_reject(r),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}a(Ma,"defaultWriterReadyPromiseReject");function so(e){i(e._readyPromise_resolve===void 0),i(e._readyPromise_reject===void 0),zr(e)}a(so,"defaultWriterReadyPromiseReset");function uo(e,r){i(e._readyPromise_resolve===void 0),i(e._readyPromise_reject===void 0),Bt(e,r)}a(uo,"defaultWriterReadyPromiseResetToRejected");function xt(e){e._readyPromise_resolve!==void 0&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}a(xt,"defaultWriterReadyPromiseResolve");function fo(){if(typeof globalThis<"u")return globalThis;if(typeof self<"u")return self;if(typeof global<"u")return global}a(fo,"getGlobals");var Na=fo();function mo(e){if(!(typeof e=="function"||typeof e=="object")||e.name!=="DOMException")return!1;try{return new e,!0}catch{return!1}}a(mo,"isDOMExceptionConstructor");function co(){let e=Na?.DOMException;return mo(e)?e:void 0}a(co,"getFromGlobal");function bo(){let e=a(function(t,n){this.message=t||"",this.name=n||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)},"DOMException");return y(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}a(bo,"createPolyfill");var Ya=co()||bo();function Ut(e,r,t,n,o,l){i(W(e)),i($(r)),i(typeof t=="boolean"),i(typeof n=="boolean"),i(typeof o=="boolean"),i(l===void 0||Or(l)),i(!D(e)),i(!fe(r));let s=se(e),d=At(r);e._disturbed=!0;let f=new jt(d),c=new zt(f);return _((b,S)=>{let h;if(l!==void 0){if(h=a(()=>{let p=l.reason!==void 0?l.reason:new Ya("Aborted","AbortError"),T=[];n||T.push(()=>r._state==="writable"?ur(r,p):m(void 0)),o||T.push(()=>e._state==="readable"?z(e,p):m(void 0)),ie(()=>Promise.all(T.reverse().map(K=>K())),!0,p,!0)},"abortAlgorithm"),l.aborted){h();return}l.addEventListener("abort",h)}function E(){return _((p,T)=>{function K(g){g?p():j(oe(),K,T)}a(K,"next"),K(!1)})}a(E,"pipeLoop");function oe(){for(;!f._shuttingDown&&!r._backpressure&&r._state==="writable"&&!U(r)&&e._state==="readable"&&it(s);)pe(s,c);if(f._shuttingDown)return m(!0);if(r._backpressure)return j(d._readyPromise,oe);let p=new Ft(f);return f._currentRead=p._promise,pe(s,p),p._promise}if(a(oe,"pipeStep"),$a(e,s._closedPromise,p=>(n?H(!0,p):ie(()=>ur(r,p),!0,p),null)),$a(r,d._closedPromise,p=>(o?H(!0,p):ie(()=>z(e,p),!0,p),null)),yo(e,s._closedPromise,()=>(t?H():ie(()=>xa(d)),null)),U(r)||r._state==="closed"){let p=new TypeError("the destination writable stream closed before all data could be piped to it");o?H(!0,p):ie(()=>z(e,p),!0,p)}X(E());function ie(p,T,K,g=!1){if(f._shuttingDown)return;f._shuttingDown=!0;let B=g?f._currentRead:void 0;Xe(B?j(B,q,q):m(void 0),()=>{r._state==="writable"&&!U(r)?Xe(f._waitForWritesToFinish(),x):x()});function x(){return w(p(),()=>C(T,K),le=>C(!0,le)),null}a(x,"doTheRest")}a(ie,"shutdownWithAction");function H(p,T){f._shuttingDown||(f._shuttingDown=!0,r._state==="writable"&&!U(r)?Xe(f._waitForWritesToFinish(),()=>C(p,T)):C(p,T))}a(H,"shutdown");function C(p,T){return qt(d),F(s),l!==void 0&&l.removeEventListener("abort",h),p?S(T):b(void 0),null}a(C,"finalize")})}a(Ut,"ReadableStreamPipeTo");var jt=class{constructor(r){this._writer=r;this._shuttingDown=!1;this._currentWrite=m(void 0)}static{a(this,"PipeState")}_waitForWritesToFinish(){let r=this._currentWrite;return j(this._currentWrite,()=>r!==this._currentWrite?this._waitForWritesToFinish():void 0)}},Ft=class{static{a(this,"PipeReadRequest")}constructor(r){this._state=r,this._promise=_((t,n)=>{this._resolvePromise=t,this._rejectPromise=n})}_chunkSteps(r){if(this._state._shuttingDown){this._resolvePromise(!1);return}this._state._currentWrite=j(xr(this._state._writer,r),void 0,q),this._resolvePromise(!1)}_closeSteps(){this._resolvePromise(!0)}_errorSteps(r){this._rejectPromise(r)}},zt=class{constructor(r){this._state=r}static{a(this,"SyncPipeReadRequest")}_chunkSteps(r){this._state._currentWrite=j(xr(this._state._writer,r),void 0,q)}_closeSteps(){Kr()}_errorSteps(r){Kr()}};function $a(e,r,t){e._state==="errored"?t(e._storedError):Ze(r,t)}a($a,"isOrBecomesErrored");function yo(e,r,t){e._state==="closed"?t():Xe(r,t)}a(yo,"isOrBecomesClosed");var G=class{static{a(this,"ReadableStreamDefaultController")}constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!Ur(this))throw Lr("desiredSize");return Vr(this)}close(){if(!Ur(this))throw Lr("close");if(!Oe(this))throw new TypeError("The stream is not in a state that permits close");ce(this)}enqueue(r=void 0){if(!Ur(this))throw Lr("enqueue");if(!Oe(this))throw new TypeError("The stream is not in a state that permits enqueue");return Se(this,r)}error(r=void 0){if(!Ur(this))throw Lr("error");N(this,r)}[je](r){ee(this);let t=this._cancelAlgorithm(r);return Qr(this),t}[Fe](r){let t=this._controlledReadableStream;if(this._queue.length>0){let n=tr(this);this._closeRequested&&this._queue.length===0?(Qr(this),Be(t)):dr(this),r._chunkSteps(n)}else Rr(t,r),dr(this)}[ze](){return this._queue.length>0}[Ue](){}};Object.defineProperties(G.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}});y(G.prototype.close,"close");y(G.prototype.enqueue,"enqueue");y(G.prototype.error,"error");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(G.prototype,Symbol.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});function Ur(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")?!1:e instanceof G}a(Ur,"IsReadableStreamDefaultController");function dr(e){if(!Ga(e))return;if(e._pulling){e._pullAgain=!0;return}i(!e._pullAgain),e._pulling=!0;let t=e._pullAlgorithm();w(t,()=>(e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,dr(e)),null),n=>(N(e,n),null))}a(dr,"ReadableStreamDefaultControllerCallPullIfNeeded");function Ga(e){let r=e._controlledReadableStream;if(!Oe(e)||!e._started)return!1;if(D(r)&&Te(r)>0)return!0;let t=Vr(e);return i(t!==null),t>0}a(Ga,"ReadableStreamDefaultControllerShouldCallPull");function Qr(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}a(Qr,"ReadableStreamDefaultControllerClearAlgorithms");function ce(e){if(!Oe(e))return;let r=e._controlledReadableStream;e._closeRequested=!0,e._queue.length===0&&(Qr(e),Be(r))}a(ce,"ReadableStreamDefaultControllerClose");function Se(e,r){if(!Oe(e))return;let t=e._controlledReadableStream;if(D(t)&&Te(t)>0)rr(t,r,!1);else{let n;try{n=e._strategySizeAlgorithm(r)}catch(o){throw N(e,o),o}try{ar(e,r,n)}catch(o){throw N(e,o),o}}dr(e)}a(Se,"ReadableStreamDefaultControllerEnqueue");function N(e,r){let t=e._controlledReadableStream;t._state==="readable"&&(ee(e),Qr(e),Ar(t,r))}a(N,"ReadableStreamDefaultControllerError");function Vr(e){let r=e._controlledReadableStream._state;return r==="errored"?null:r==="closed"?0:e._strategyHWM-e._queueTotalSize}a(Vr,"ReadableStreamDefaultControllerGetDesiredSize");function Ha(e){return!Ga(e)}a(Ha,"ReadableStreamDefaultControllerHasBackpressure");function Oe(e){let r=e._controlledReadableStream._state;return!e._closeRequested&&r==="readable"}a(Oe,"ReadableStreamDefaultControllerCanCloseOrEnqueue");function Lt(e,r,t,n,o,l,s){i(e._readableStreamController===void 0),r._controlledReadableStream=e,r._queue=void 0,r._queueTotalSize=void 0,ee(r),r._started=!1,r._closeRequested=!1,r._pullAgain=!1,r._pulling=!1,r._strategySizeAlgorithm=s,r._strategyHWM=l,r._pullAlgorithm=n,r._cancelAlgorithm=o,e._readableStreamController=r;let d=t();w(m(d),()=>(r._started=!0,i(!r._pulling),i(!r._pullAgain),dr(r),null),f=>(N(r,f),null))}a(Lt,"SetUpReadableStreamDefaultController");function Ka(e,r,t,n){let o=Object.create(G.prototype),l,s,d;r.start!==void 0?l=a(()=>r.start(o),"startAlgorithm"):l=a(()=>{},"startAlgorithm"),r.pull!==void 0?s=a(()=>r.pull(o),"pullAlgorithm"):s=a(()=>m(void 0),"pullAlgorithm"),r.cancel!==void 0?d=a(f=>r.cancel(f),"cancelAlgorithm"):d=a(()=>m(void 0),"cancelAlgorithm"),Lt(e,o,l,s,d,t,n)}a(Ka,"SetUpReadableStreamDefaultControllerFromUnderlyingSource");function Lr(e){return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`)}a(Lr,"defaultControllerBrandCheckException");function Xa(e,r){return i(W(e)),i(typeof r=="boolean"),re(e._readableStreamController)?So(e):po(e,r)}a(Xa,"ReadableStreamTee");function po(e,r){i(W(e)),i(typeof r=="boolean");let t=se(e),n=!1,o=!1,l=!1,s=!1,d,f,c,b,S,h=_(C=>{S=C});function E(){return n?(o=!0,m(void 0)):(n=!0,pe(t,{_chunkSteps:a(p=>{ye(()=>{o=!1;let T=p,K=p;l||Se(c._readableStreamController,T),s||Se(b._readableStreamController,K),n=!1,o&&E()})},"_chunkSteps"),_closeSteps:a(()=>{n=!1,l||ce(c._readableStreamController),s||ce(b._readableStreamController),(!l||!s)&&S(void 0)},"_closeSteps"),_errorSteps:a(()=>{n=!1},"_errorSteps")}),m(void 0))}a(E,"pullAlgorithm");function oe(C){if(l=!0,d=C,s){let T=z(e,C);S(T)}return h}a(oe,"cancel1Algorithm");function ie(C){if(s=!0,f=C,l){let T=z(e,C);S(T)}return h}a(ie,"cancel2Algorithm");function H(){}return a(H,"startAlgorithm"),c=ge(H,E,oe),b=ge(H,E,ie),Ze(t._closedPromise,C=>(N(c._readableStreamController,C),N(b._readableStreamController,C),(!l||!s)&&S(void 0),null)),[c,b]}a(po,"ReadableStreamDefaultTee");function So(e){i(W(e)),i(re(e._readableStreamController));let r=se(e),t=!1,n=!1,o=!1,l=!1,s=!1,d,f,c,b,S,h=_(g=>{S=g});function E(g){Ze(g._closedPromise,B=>(g!==r||(M(c._readableStreamController,B),M(b._readableStreamController,B),(!l||!s)&&S(void 0)),null))}a(E,"forwardReaderError");function oe(){te(r)&&(i(r._readIntoRequests.length===0),F(r),r=se(e),E(r)),pe(r,{_chunkSteps:a(B=>{ye(()=>{n=!1,o=!1;let x=B,le=B;if(!l&&!s)try{le=mt(B)}catch(fr){M(c._readableStreamController,fr),M(b._readableStreamController,fr),S(z(e,fr));return}l||or(c._readableStreamController,x),s||or(b._readableStreamController,le),t=!1,n?H():o&&C()})},"_chunkSteps"),_closeSteps:a(()=>{t=!1,l||$e(c._readableStreamController),s||$e(b._readableStreamController),c._readableStreamController._pendingPullIntos.length>0&&ir(c._readableStreamController,0),b._readableStreamController._pendingPullIntos.length>0&&ir(b._readableStreamController,0),(!l||!s)&&S(void 0)},"_closeSteps"),_errorSteps:a(()=>{t=!1},"_errorSteps")})}a(oe,"pullWithDefaultReader");function ie(g,B){V(r)&&(i(r._readRequests.length===0),F(r),r=kr(e),E(r));let x=B?b:c,le=B?c:b;Tt(r,g,1,{_chunkSteps:a(Ce=>{ye(()=>{n=!1,o=!1;let xe=B?s:l;if(B?l:s)xe||lr(x._readableStreamController,Ce);else{let Ht;try{Ht=mt(Ce)}catch(Hr){M(x._readableStreamController,Hr),M(le._readableStreamController,Hr),S(z(e,Hr));return}xe||lr(x._readableStreamController,Ce),or(le._readableStreamController,Ht)}t=!1,n?H():o&&C()})},"_chunkSteps"),_closeSteps:a(Ce=>{t=!1;let xe=B?s:l,mr=B?l:s;xe||$e(x._readableStreamController),mr||$e(le._readableStreamController),Ce!==void 0&&(i(Ce.byteLength===0),xe||lr(x._readableStreamController,Ce),!mr&&le._readableStreamController._pendingPullIntos.length>0&&ir(le._readableStreamController,0)),(!xe||!mr)&&S(void 0)},"_closeSteps"),_errorSteps:a(()=>{t=!1},"_errorSteps")})}a(ie,"pullWithBYOBReader");function H(){if(t)return n=!0,m(void 0);t=!0;let g=vr(c._readableStreamController);return g===null?oe():ie(g._view,!1),m(void 0)}a(H,"pull1Algorithm");function C(){if(t)return o=!0,m(void 0);t=!0;let g=vr(b._readableStreamController);return g===null?oe():ie(g._view,!0),m(void 0)}a(C,"pull2Algorithm");function p(g){if(l=!0,d=g,s){let x=z(e,g);S(x)}return h}a(p,"cancel1Algorithm");function T(g){if(s=!0,f=g,l){let x=z(e,g);S(x)}return h}a(T,"cancel2Algorithm");function K(){}return a(K,"startAlgorithm"),c=Qt(K,H,p),b=Qt(K,C,T),E(r),[c,b]}a(So,"ReadableByteStreamTee");function Za(e){return R(e)&&typeof e.getReader<"u"}a(Za,"isReadableStreamLike");function Ja(e){return Za(e)?ho(e.getReader()):Ro(e)}a(Ja,"ReadableStreamFrom");function Ro(e){let r,t=ut(e,"async"),n=q;function o(){let s;try{s=dt(t)}catch(f){return u(f)}let d=m(s);return L(d,f=>{if(!R(f))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(f.done)ce(r._readableStreamController);else{let b=f.value;Se(r._readableStreamController,b)}})}a(o,"pullAlgorithm");function l(s){let d=t.iterator,f;try{f=Ne(d,"return")}catch(b){return u(b)}if(f===void 0)return m(void 0);let c=Q(f,d,[s]);return L(c,b=>{if(!R(b))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return a(l,"cancelAlgorithm"),r=ge(n,o,l,0),r}a(Ro,"ReadableStreamFromIterable");function ho(e){let r,t=q;function n(){let l;try{l=e.read()}catch(s){return u(s)}return L(l,s=>{if(!R(s))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(s.done)ce(r._readableStreamController);else{let d=s.value;Se(r._readableStreamController,d)}})}a(n,"pullAlgorithm");function o(l){try{return m(e.cancel(l))}catch(s){return u(s)}}return a(o,"cancelAlgorithm"),r=ge(t,n,o,0),r}a(ho,"ReadableStreamFromDefaultReader");function en(e,r){v(e,r);let t=e,n=t?.autoAllocateChunkSize,o=t?.cancel,l=t?.pull,s=t?.start,d=t?.type;return{autoAllocateChunkSize:n===void 0?void 0:Ve(n,`${r} has member 'autoAllocateChunkSize' that`),cancel:o===void 0?void 0:_o(o,t,`${r} has member 'cancel' that`),pull:l===void 0?void 0:go(l,t,`${r} has member 'pull' that`),start:s===void 0?void 0:Co(s,t,`${r} has member 'start' that`),type:d===void 0?void 0:To(d,`${r} has member 'type' that`)}}a(en,"convertUnderlyingDefaultOrByteSource");function _o(e,r,t){return k(e,t),n=>Q(e,r,[n])}a(_o,"convertUnderlyingSourceCancelCallback");function go(e,r,t){return k(e,t),n=>Q(e,r,[n])}a(go,"convertUnderlyingSourcePullCallback");function Co(e,r,t){return k(e,t),n=>Z(e,r,[n])}a(Co,"convertUnderlyingSourceStartCallback");function To(e,r){if(e=`${e}`,e!=="bytes")throw new TypeError(`${r} '${e}' is not a valid enumeration value for ReadableStreamType`);return e}a(To,"convertReadableStreamType");function rn(e,r){return v(e,r),{preventCancel:!!e?.preventCancel}}a(rn,"convertIteratorOptions");function Vt(e,r){v(e,r);let t=e?.preventAbort,n=e?.preventCancel,o=e?.preventClose,l=e?.signal;return l!==void 0&&Po(l,`${r} has member 'signal' that`),{preventAbort:!!t,preventCancel:!!n,preventClose:!!o,signal:l}}a(Vt,"convertPipeOptions");function Po(e,r){if(!Or(e))throw new TypeError(`${r} is not an AbortSignal.`)}a(Po,"assertAbortSignal");function tn(e,r){v(e,r);let t=e?.readable;Je(t,"readable","ReadableWritablePair"),Me(t,`${r} has member 'readable' that`);let n=e?.writable;return Je(n,"writable","ReadableWritablePair"),Ir(n,`${r} has member 'writable' that`),{readable:t,writable:n}}a(tn,"convertReadableWritablePair");var A=class{static{a(this,"ReadableStream")}constructor(r={},t={}){r===void 0?r=null:pr(r,"First parameter");let n=We(t,"Second parameter"),o=en(r,"First parameter");if(Mt(this),o.type==="bytes"){if(n.size!==void 0)throw new RangeError("The strategy for a byte stream cannot have a size function");let l=he(n,0);Pa(this,o,l)}else{i(o.type===void 0);let l=Ae(n),s=he(n,1);Ka(this,o,s,l)}}get locked(){if(!W(this))throw qe("locked");return D(this)}cancel(r=void 0){return W(this)?D(this)?u(new TypeError("Cannot cancel a stream that already has a reader")):z(this,r):u(qe("cancel"))}getReader(r=void 0){if(!W(this))throw qe("getReader");let t=va(r,"First parameter");return t.mode===void 0?se(this):(i(t.mode==="byob"),kr(this))}pipeThrough(r,t={}){if(!W(this))throw qe("pipeThrough");I(r,1,"pipeThrough");let n=tn(r,"First parameter"),o=Vt(t,"Second parameter");if(D(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(fe(n.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");let l=Ut(this,n.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal);return X(l),n.readable}pipeTo(r,t={}){if(!W(this))return u(qe("pipeTo"));if(r===void 0)return u("Parameter 1 is required in 'pipeTo'.");if(!$(r))return u(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));let n;try{n=Vt(t,"Second parameter")}catch(o){return u(o)}return D(this)?u(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):fe(r)?u(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Ut(this,r,n.preventClose,n.preventAbort,n.preventCancel,n.signal)}tee(){if(!W(this))throw qe("tee");let r=Xa(this,!1);return ea(r)}values(r=void 0){if(!W(this))throw qe("values");let t=rn(r,"First parameter");return ia(this,t.preventCancel)}[Pe](r){return this.values(r)}static from(r){return Ja(r)}};Object.defineProperties(A,{from:{enumerable:!0}});Object.defineProperties(A.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}});y(A.from,"from");y(A.prototype.cancel,"cancel");y(A.prototype.getReader,"getReader");y(A.prototype.pipeThrough,"pipeThrough");y(A.prototype.pipeTo,"pipeTo");y(A.prototype.tee,"tee");y(A.prototype.values,"values");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(A.prototype,Symbol.toStringTag,{value:"ReadableStream",configurable:!0});Object.defineProperty(A.prototype,Pe,{value:A.prototype.values,writable:!0,configurable:!0});function ge(e,r,t,n=1,o=()=>1){i(we(n));let l=Object.create(A.prototype);Mt(l);let s=Object.create(G.prototype);return Lt(l,s,e,r,t,n,o),l}a(ge,"CreateReadableStream");function Qt(e,r,t){let n=Object.create(A.prototype);Mt(n);let o=Object.create(Y.prototype);return ht(n,o,e,r,t,0,void 0),n}a(Qt,"CreateReadableByteStream");function Mt(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}a(Mt,"InitializeReadableStream");function W(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")?!1:e instanceof A}a(W,"IsReadableStream");function D(e){return i(W(e)),e._reader!==void 0}a(D,"IsReadableStreamLocked");function z(e,r){if(e._disturbed=!0,e._state==="closed")return m(void 0);if(e._state==="errored")return u(e._storedError);Be(e);let t=e._reader;if(t!==void 0&&te(t)){let o=t._readIntoRequests;t._readIntoRequests=new P,o.forEach(l=>{l._closeSteps(void 0)})}let n=e._readableStreamController[je](r);return L(n,q)}a(z,"ReadableStreamCancel");function Be(e){i(e._state==="readable"),e._state="closed";let r=e._reader;if(r!==void 0&&(tt(r),V(r))){let t=r._readRequests;r._readRequests=new P,t.forEach(n=>{n._closeSteps()})}}a(Be,"ReadableStreamClose");function Ar(e,r){i(W(e)),i(e._state==="readable"),e._state="errored",e._storedError=r;let t=e._reader;t!==void 0&&(yr(t,r),V(t)?lt(t,r):(i(te(t)),Pt(t,r)))}a(Ar,"ReadableStreamError");function qe(e){return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`)}a(qe,"streamBrandCheckException");function Mr(e,r){v(e,r);let t=e?.highWaterMark;return Je(t,"highWaterMark","QueuingStrategyInit"),{highWaterMark:er(t)}}a(Mr,"convertQueuingStrategyInit");var on=a(e=>e.byteLength,"byteLengthSizeFunction");y(on,"size");var De=class{static{a(this,"ByteLengthQueuingStrategy")}constructor(r){I(r,1,"ByteLengthQueuingStrategy"),r=Mr(r,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=r.highWaterMark}get highWaterMark(){if(!nn(this))throw an("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark}get size(){if(!nn(this))throw an("size");return on}};Object.defineProperties(De.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}});typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(De.prototype,Symbol.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});function an(e){return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`)}a(an,"byteLengthBrandCheckException");function nn(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")?!1:e instanceof De}a(nn,"IsByteLengthQueuingStrategy");var un=a(()=>1,"countSizeFunction");y(un,"size");var Ee=class{static{a(this,"CountQueuingStrategy")}constructor(r){I(r,1,"CountQueuingStrategy"),r=Mr(r,"First parameter"),this._countQueuingStrategyHighWaterMark=r.highWaterMark}get highWaterMark(){if(!sn(this))throw ln("highWaterMark");return this._countQueuingStrategyHighWaterMark}get size(){if(!sn(this))throw ln("size");return un}};Object.defineProperties(Ee.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}});typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(Ee.prototype,Symbol.toStringTag,{value:"CountQueuingStrategy",configurable:!0});function ln(e){return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`)}a(ln,"countBrandCheckException");function sn(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")?!1:e instanceof Ee}a(sn,"IsCountQueuingStrategy");function dn(e,r){v(e,r);let t=e?.cancel,n=e?.flush,o=e?.readableType,l=e?.start,s=e?.transform,d=e?.writableType;return{cancel:t===void 0?void 0:Ao(t,e,`${r} has member 'cancel' that`),flush:n===void 0?void 0:wo(n,e,`${r} has member 'flush' that`),readableType:o,start:l===void 0?void 0:vo(l,e,`${r} has member 'start' that`),transform:s===void 0?void 0:Bo(s,e,`${r} has member 'transform' that`),writableType:d}}a(dn,"convertTransformer");function wo(e,r,t){return k(e,t),n=>Q(e,r,[n])}a(wo,"convertTransformerFlushCallback");function vo(e,r,t){return k(e,t),n=>Z(e,r,[n])}a(vo,"convertTransformerStartCallback");function Bo(e,r,t){return k(e,t),(n,o)=>Q(e,r,[n,o])}a(Bo,"convertTransformerTransformCallback");function Ao(e,r,t){return k(e,t),n=>Q(e,r,[n])}a(Ao,"convertTransformerCancelCallback");var He=class{static{a(this,"TransformStream")}constructor(r={},t={},n={}){r===void 0&&(r=null);let o=We(t,"Second parameter"),l=We(n,"Third parameter"),s=dn(r,"First parameter");if(s.readableType!==void 0)throw new RangeError("Invalid readableType specified");if(s.writableType!==void 0)throw new RangeError("Invalid writableType specified");let d=he(l,0),f=Ae(l),c=he(o,1),b=Ae(o),S,h=_(E=>{S=E});Wo(this,h,c,b,d,f),Io(this,s),s.start!==void 0?S(s.start(this._transformStreamController)):S(void 0)}get readable(){if(!Nt(this))throw mn("readable");return this._readable}get writable(){if(!Nt(this))throw mn("writable");return this._writable}};Object.defineProperties(He.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}});typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(He.prototype,Symbol.toStringTag,{value:"TransformStream",configurable:!0});function Wo(e,r,t,n,o,l){function s(){return r}a(s,"startAlgorithm");function d(h){return Do(e,h)}a(d,"writeAlgorithm");function f(h){return Eo(e,h)}a(f,"abortAlgorithm");function c(){return xo(e)}a(c,"closeAlgorithm"),e._writable=Ia(s,d,c,f,t,n);function b(){return jo(e)}a(b,"pullAlgorithm");function S(h){return Fo(e,h)}a(S,"cancelAlgorithm"),e._readable=ge(s,b,S,o,l),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,$r(e,!0),e._transformStreamController=void 0}a(Wo,"InitializeTransformStream");function Nt(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")?!1:e instanceof He}a(Nt,"IsTransformStream");function cn(e,r){N(e._readable._readableStreamController,r),$t(e,r)}a(cn,"TransformStreamError");function $t(e,r){Gr(e._transformStreamController),Ge(e._writable._writableStreamController,r),Yt(e)}a($t,"TransformStreamErrorWritableAndUnblockWrite");function Yt(e){e._backpressure&&$r(e,!1)}a(Yt,"TransformStreamUnblockWrite");function $r(e,r){i(e._backpressure!==r),e._backpressureChangePromise!==void 0&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=_(t=>{e._backpressureChangePromise_resolve=t}),e._backpressure=r}a($r,"TransformStreamSetBackpressure");var be=class{static{a(this,"TransformStreamDefaultController")}constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!Nr(this))throw Yr("desiredSize");let r=this._controlledTransformStream._readable._readableStreamController;return Vr(r)}enqueue(r=void 0){if(!Nr(this))throw Yr("enqueue");bn(this,r)}error(r=void 0){if(!Nr(this))throw Yr("error");Oo(this,r)}terminate(){if(!Nr(this))throw Yr("terminate");qo(this)}};Object.defineProperties(be.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}});y(be.prototype.enqueue,"enqueue");y(be.prototype.error,"error");y(be.prototype.terminate,"terminate");typeof Symbol.toStringTag=="symbol"&&Object.defineProperty(be.prototype,Symbol.toStringTag,{value:"TransformStreamDefaultController",configurable:!0});function Nr(e){return!R(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")?!1:e instanceof be}a(Nr,"IsTransformStreamDefaultController");function ko(e,r,t,n,o){i(Nt(e)),i(e._transformStreamController===void 0),r._controlledTransformStream=e,e._transformStreamController=r,r._transformAlgorithm=t,r._flushAlgorithm=n,r._cancelAlgorithm=o,r._finishPromise=void 0,r._finishPromise_resolve=void 0,r._finishPromise_reject=void 0}a(ko,"SetUpTransformStreamDefaultController");function Io(e,r){let t=Object.create(be.prototype),n,o,l;r.transform!==void 0?n=a(s=>r.transform(s,t),"transformAlgorithm"):n=a(s=>{try{return bn(t,s),m(void 0)}catch(d){return u(d)}},"transformAlgorithm"),r.flush!==void 0?o=a(()=>r.flush(t),"flushAlgorithm"):o=a(()=>m(void 0),"flushAlgorithm"),r.cancel!==void 0?l=a(s=>r.cancel(s),"cancelAlgorithm"):l=a(()=>m(void 0),"cancelAlgorithm"),ko(e,t,n,o,l)}a(Io,"SetUpTransformStreamDefaultControllerFromTransformer");function Gr(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}a(Gr,"TransformStreamDefaultControllerClearAlgorithms");function bn(e,r){let t=e._controlledTransformStream,n=t._readable._readableStreamController;if(!Oe(n))throw new TypeError("Readable side is not in a state that permits enqueue");try{Se(n,r)}catch(l){throw $t(t,l),t._readable._storedError}let o=Ha(n);o!==t._backpressure&&(i(o),$r(t,!0))}a(bn,"TransformStreamDefaultControllerEnqueue");function Oo(e,r){cn(e._controlledTransformStream,r)}a(Oo,"TransformStreamDefaultControllerError");function fn(e,r){let t=e._transformAlgorithm(r);return L(t,void 0,n=>{throw cn(e._controlledTransformStream,n),n})}a(fn,"TransformStreamDefaultControllerPerformTransform");function qo(e){let r=e._controlledTransformStream,t=r._readable._readableStreamController;ce(t);let n=new TypeError("TransformStream terminated");$t(r,n)}a(qo,"TransformStreamDefaultControllerTerminate");function Do(e,r){i(e._writable._state==="writable");let t=e._transformStreamController;if(e._backpressure){let n=e._backpressureChangePromise;return i(n!==void 0),L(n,()=>{let o=e._writable,l=o._state;if(l==="erroring")throw o._storedError;return i(l==="writable"),fn(t,r)})}return fn(t,r)}a(Do,"TransformStreamDefaultSinkWriteAlgorithm");function Eo(e,r){let t=e._transformStreamController;if(t._finishPromise!==void 0)return t._finishPromise;let n=e._readable;t._finishPromise=_((l,s)=>{t._finishPromise_resolve=l,t._finishPromise_reject=s});let o=t._cancelAlgorithm(r);return Gr(t),w(o,()=>(n._state==="errored"?Ke(t,n._storedError):(N(n._readableStreamController,r),Gt(t)),null),l=>(N(n._readableStreamController,l),Ke(t,l),null)),t._finishPromise}a(Eo,"TransformStreamDefaultSinkAbortAlgorithm");function xo(e){let r=e._transformStreamController;if(r._finishPromise!==void 0)return r._finishPromise;let t=e._readable;r._finishPromise=_((o,l)=>{r._finishPromise_resolve=o,r._finishPromise_reject=l});let n=r._flushAlgorithm();return Gr(r),w(n,()=>(t._state==="errored"?Ke(r,t._storedError):(ce(t._readableStreamController),Gt(r)),null),o=>(N(t._readableStreamController,o),Ke(r,o),null)),r._finishPromise}a(xo,"TransformStreamDefaultSinkCloseAlgorithm");function jo(e){return i(e._backpressure),i(e._backpressureChangePromise!==void 0),$r(e,!1),e._backpressureChangePromise}a(jo,"TransformStreamDefaultSourcePullAlgorithm");function Fo(e,r){let t=e._transformStreamController;if(t._finishPromise!==void 0)return t._finishPromise;let n=e._writable;t._finishPromise=_((l,s)=>{t._finishPromise_resolve=l,t._finishPromise_reject=s});let o=t._cancelAlgorithm(r);return Gr(t),w(o,()=>(n._state==="errored"?Ke(t,n._storedError):(Ge(n._writableStreamController,r),Yt(e),Gt(t)),null),l=>(Ge(n._writableStreamController,l),Yt(e),Ke(t,l),null)),t._finishPromise}a(Fo,"TransformStreamDefaultSourceCancelAlgorithm");function Yr(e){return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`)}a(Yr,"defaultControllerBrandCheckException");function Gt(e){e._finishPromise_resolve!==void 0&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}a(Gt,"defaultControllerFinishPromiseResolve");function Ke(e,r){e._finishPromise_reject!==void 0&&(X(e._finishPromise),e._finishPromise_reject(r),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}a(Ke,"defaultControllerFinishPromiseReject");function mn(e){return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`)}a(mn,"streamBrandCheckException");export{De as ByteLengthQueuingStrategy,Ee as CountQueuingStrategy,Y as ReadableByteStreamController,A as ReadableStream,ae as ReadableStreamBYOBReader,de as ReadableStreamBYOBRequest,G as ReadableStreamDefaultController,J as ReadableStreamDefaultReader,He as TransformStream,be as TransformStreamDefaultController,me as WritableStream,_e as WritableStreamDefaultController,ne as WritableStreamDefaultWriter}; diff --git a/src/compat/stream-wrap/LICENSE-3RD-PARTY.md b/src/compat/stream-wrap/LICENSE-3RD-PARTY.md new file mode 100644 index 00000000..5af46473 --- /dev/null +++ b/src/compat/stream-wrap/LICENSE-3RD-PARTY.md @@ -0,0 +1,11 @@ +# Upstream notices + +This module ports Cloudflare workerd tag `v1.20261012.1`, revision +`5358e3d337336eaf696a48bc1563d808b10feba5`: + +- `src/node/_tls_common.ts` +- `src/node/internal/internal_tls_common.ts` + +Copyright Cloudflare, Inc.; Apache License 2.0. Node.js/Joyent MIT notices +are preserved in the source files. Imports, resource-management symbols and +host constructor references are adapted for the Capacitor runtime. diff --git a/src/compat/stream-wrap/LICENSE-APACHE b/src/compat/stream-wrap/LICENSE-APACHE new file mode 100644 index 00000000..f433b1a5 --- /dev/null +++ b/src/compat/stream-wrap/LICENSE-APACHE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/src/compat/stream-wrap/index.ts b/src/compat/stream-wrap/index.ts new file mode 100644 index 00000000..c98434f3 --- /dev/null +++ b/src/compat/stream-wrap/index.ts @@ -0,0 +1 @@ +export { JSStreamSocket as default } from "../tls/jsstream.js"; diff --git a/src/compat/tls-wrap/LICENSE-3RD-PARTY.md b/src/compat/tls-wrap/LICENSE-3RD-PARTY.md new file mode 100644 index 00000000..5af46473 --- /dev/null +++ b/src/compat/tls-wrap/LICENSE-3RD-PARTY.md @@ -0,0 +1,11 @@ +# Upstream notices + +This module ports Cloudflare workerd tag `v1.20261012.1`, revision +`5358e3d337336eaf696a48bc1563d808b10feba5`: + +- `src/node/_tls_common.ts` +- `src/node/internal/internal_tls_common.ts` + +Copyright Cloudflare, Inc.; Apache License 2.0. Node.js/Joyent MIT notices +are preserved in the source files. Imports, resource-management symbols and +host constructor references are adapted for the Capacitor runtime. diff --git a/src/compat/tls-wrap/LICENSE-APACHE b/src/compat/tls-wrap/LICENSE-APACHE new file mode 100644 index 00000000..f433b1a5 --- /dev/null +++ b/src/compat/tls-wrap/LICENSE-APACHE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/src/compat/tls-wrap/index.ts b/src/compat/tls-wrap/index.ts new file mode 100644 index 00000000..4bc14888 --- /dev/null +++ b/src/compat/tls-wrap/index.ts @@ -0,0 +1,3 @@ +export { connect, TLSSocket } from "../tls/wrap.js"; +import { connect, TLSSocket } from "../tls/wrap.js"; +export default { connect, TLSSocket }; diff --git a/src/compat/tls/LICENSE-3RD-PARTY.md b/src/compat/tls/LICENSE-3RD-PARTY.md new file mode 100644 index 00000000..5af46473 --- /dev/null +++ b/src/compat/tls/LICENSE-3RD-PARTY.md @@ -0,0 +1,11 @@ +# Upstream notices + +This module ports Cloudflare workerd tag `v1.20261012.1`, revision +`5358e3d337336eaf696a48bc1563d808b10feba5`: + +- `src/node/_tls_common.ts` +- `src/node/internal/internal_tls_common.ts` + +Copyright Cloudflare, Inc.; Apache License 2.0. Node.js/Joyent MIT notices +are preserved in the source files. Imports, resource-management symbols and +host constructor references are adapted for the Capacitor runtime. diff --git a/src/compat/tls/LICENSE-APACHE b/src/compat/tls/LICENSE-APACHE new file mode 100644 index 00000000..f433b1a5 --- /dev/null +++ b/src/compat/tls/LICENSE-APACHE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/src/compat/tls/README.md b/src/compat/tls/README.md new file mode 100644 index 00000000..122a1fe4 --- /dev/null +++ b/src/compat/tls/README.md @@ -0,0 +1,22 @@ +# Workers TLS adapter + +Adapted from workerd 5358e3d337336eaf696a48bc1563d808b10feba5. +The public tls, \_tls_wrap and \_stream_wrap imports share their constructors. +Certificate hostname checks, ALPN conversion, constants, options validation and +Workers stubs follow the pinned profile. Direct TLS connections use the existing +native socket transport and platform certificate verification. The original +hostname or explicit servername survives DNS resolution and reaches the native +TLS verifier and SNI configuration. + +The native expansion suite verifies successful TLS exchange and hostname mismatch +rejection in both page and Dedicated Worker on iOS and Android. Dedicated Workers +use the normal owned socket relay, including disposal. Trust overrides are confined +to the independent debug test consumer and simulator CA store. + +Whole-module acceptance remains open. In-place upgrade of an existing plaintext +socket is not implemented by the current native transport; it must not reconnect +and silently discard the protocol state. This is an implementation gap requiring +transport work, not an impossibility claim. Further socket lifecycle/prototype and +error-path coverage is also required. Workers itself rejects server mode, custom +verification callbacks, ALPN negotiation options and several introspection APIs +in the pinned profile; retain those explicit failures. diff --git a/src/compat/tls/constants.ts b/src/compat/tls/constants.ts new file mode 100644 index 00000000..2333cc5c --- /dev/null +++ b/src/compat/tls/constants.ts @@ -0,0 +1,17 @@ +// @ts-nocheck +import { Buffer } from "node:buffer"; +// Copyright (c) 2026 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 + +// Allow {CLIENT_RENEG_LIMIT} client-initiated session renegotiations +// every {CLIENT_RENEG_WINDOW} seconds. An error event is emitted if more +// renegotiations are seen. The settings are applied to all remote client +// connections. +export const CLIENT_RENEG_LIMIT = 3; +export const CLIENT_RENEG_WINDOW = 600; +export const DEFAULT_CIPHERS = ""; +export const DEFAULT_ECDH_CURVE = "auto"; +export const DEFAULT_MIN_VERSION = "TLSv1.2"; +export const DEFAULT_MAX_VERSION = "TLSv1.3"; +export const rootCertificates = []; diff --git a/src/compat/tls/errors.ts b/src/compat/tls/errors.ts new file mode 100644 index 00000000..818b3407 --- /dev/null +++ b/src/compat/tls/errors.ts @@ -0,0 +1,93 @@ +// @ts-nocheck +// Adapted from pinned workerd internal_errors.ts (Apache-2.0 / Node MIT). +import { NodeError, NodeTypeError } from "../net/error-base.js"; +import type { PeerCertificate } from "node:tls"; +class NodeSyntaxError extends SyntaxError { + constructor(code, message) { + super(message); + this.code = code; + } +} +export { ERR_OUT_OF_RANGE, ERR_OPTION_NOT_IMPLEMENTED } from "../net/errors.js"; +export class ERR_TLS_HANDSHAKE_TIMEOUT extends NodeError { + constructor() { + super("ERR_TLS_HANDSHAKE_TIMEOUT", "TLS handshake timeout"); + } +} + +export class ERR_TLS_INVALID_CONTEXT extends NodeTypeError { + constructor(field: string) { + super("ERR_TLS_INVALID_CONTEXT", `${field} must be a SecureContext`); + } +} + +export class ERR_TLS_CERT_ALTNAME_INVALID extends NodeError { + reason: string; + host: string; + cert?: Partial | undefined; + + constructor(reason: string, host: string, cert?: Partial) { + super("ERR_TLS_CERT_ALTNAME_INVALID", reason); + this.reason = reason; + this.host = host; + this.cert = cert; + } +} + +export class ERR_TLS_CERT_ALTNAME_FORMAT extends NodeSyntaxError { + constructor() { + super( + "ERR_TLS_CERT_ALTNAME_FORMAT", + "Invalid subject alternative name string", + ); + } +} + +export class ConnResetException extends NodeError { + path?: string | undefined; + host?: string | undefined; + port?: number | undefined; + localAddress?: string | undefined; + + constructor(message: string) { + super("ECONNRESET", message); + } +} + +export function aggregateTwoErrors( + innerError: unknown, + outerError: Error | null | undefined, +): AggregateError { + if (innerError && outerError && innerError !== outerError) { + if ("errors" in outerError && Array.isArray(outerError.errors)) { + // If `outerError` is already an `AggregateError`. + outerError.errors.push(innerError); + return outerError as AggregateError; + } + const err = new AggregateError( + [outerError, innerError], + outerError.message, + ); + (err as unknown as NodeError).code = (outerError as NodeError).code; + return err; + } + return (innerError || outerError) as AggregateError; +} + +export class ERR_STREAM_WRAP extends NodeError { + constructor() { + super( + "ERR_STREAM_WRAP", + "Stream has StringDecoder set or is in objectMode", + ); + } +} + +export class ERR_METHOD_NOT_IMPLEMENTED extends NodeError { + constructor(name: string) { + super( + "ERR_METHOD_NOT_IMPLEMENTED", + `The ${name} method is not implemented`, + ); + } +} diff --git a/src/compat/tls/helpers.ts b/src/compat/tls/helpers.ts new file mode 100644 index 00000000..62910970 --- /dev/null +++ b/src/compat/tls/helpers.ts @@ -0,0 +1,277 @@ +// @ts-nocheck +import { Buffer } from "node:buffer"; +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +import type { PeerCertificate } from "node:tls"; +import { isIP } from "../net/internal-net.js"; +const urlUtil = { + canonicalizeIp(ip: string) { + // URL's IPv6 serializer expands equivalent spellings to one canonical form. + if (isIP(ip) === 6) return new URL(`http://[${ip}]/`).hostname.slice(1, -1); + return ip; + }, +}; +import { + ERR_TLS_CERT_ALTNAME_INVALID, + ERR_TLS_CERT_ALTNAME_FORMAT, + ERR_OUT_OF_RANGE, +} from "./errors.js"; +import { isUint8Array, isArrayBufferView } from "../util/types/index.js"; + +// String#toLowerCase() is locale-sensitive so we use +// a conservative version that only lowercases A-Z. +function toLowerCase(c: string): string { + return String.fromCharCode(32 + c.charCodeAt(0)); +} + +function unfqdn(host: string): string { + return host.replace(/[.]$/, ""); +} + +function splitHost(host: string): string[] { + return unfqdn(host).replace(/[A-Z]/g, toLowerCase).split("."); +} + +function check( + hostParts: string[], + pattern: string | undefined | null, + wildcards: boolean, +): boolean { + // Empty strings, null, undefined, etc. never match. + if (!pattern) return false; + + const patternParts = splitHost(pattern); + + if (hostParts.length !== patternParts.length) return false; + + // Pattern has empty components, e.g. "bad..example.com". + if (patternParts.includes("")) return false; + + // RFC 6125 allows IDNA U-labels (Unicode) in names but we have no + // good way to detect their encoding or normalize them so we simply + // reject them. Control characters and blanks are rejected as well + // because nothing good can come from accepting them. + const isBad = (s: string): boolean => /[^\u0021-\u007F]/u.test(s); + if (patternParts.some(isBad)) return false; + + // Check host parts from right to left first. + for (let i = hostParts.length - 1; i > 0; i -= 1) { + if (hostParts[i] !== patternParts[i]) return false; + } + + const hostSubdomain = hostParts[0] as string; + const patternSubdomain = patternParts[0] as string; + const patternSubdomainParts = patternSubdomain.split("*", 3); + + // Short-circuit when the subdomain does not contain a wildcard. + // RFC 6125 does not allow wildcard substitution for components + // containing IDNA A-labels (Punycode) so match those verbatim. + if (patternSubdomainParts.length === 1 || patternSubdomain.includes("xn--")) + return hostSubdomain === patternSubdomain; + + if (!wildcards) return false; + + // More than one wildcard is always wrong. + if (patternSubdomainParts.length > 2) return false; + + // *.tld wildcards are not allowed. + if (patternParts.length <= 2) return false; + + const { 0: prefix, 1: suffix } = patternSubdomainParts as [string, string]; + + if (prefix.length + suffix.length > hostSubdomain.length) return false; + + if (!hostSubdomain.startsWith(prefix)) return false; + + if (!hostSubdomain.endsWith(suffix)) return false; + + return true; +} + +// This pattern is used to determine the length of escaped sequences within +// the subject alt names string. It allows any valid JSON string literal. +// This MUST match the JSON specification (ECMA-404 / RFC8259) exactly. +const jsonStringPattern = + // eslint-disable-next-line no-control-regex + /^"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/; + +function splitEscapedAltNames(altNames: string): string[] { + const result = []; + let currentToken = ""; + let offset = 0; + while (offset !== altNames.length) { + const nextSep = altNames.indexOf(",", offset); + const nextQuote = altNames.indexOf('"', offset); + if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) { + // There is a quote character and there is no separator before the quote. + currentToken += altNames.substring(offset, nextQuote); + const match = jsonStringPattern.exec(altNames.substring(nextQuote)); + if (!match) { + throw new ERR_TLS_CERT_ALTNAME_FORMAT(); + } + currentToken += JSON.parse(match[0]) as string; + offset = nextQuote + match[0].length; + } else if (nextSep !== -1) { + // There is a separator and no quote before it. + currentToken += altNames.substring(offset, nextSep); + result.push(currentToken); + currentToken = ""; + offset = nextSep + 2; + } else { + currentToken += altNames.substring(offset); + offset = altNames.length; + } + } + result.push(currentToken); + return result; +} + +export function checkServerIdentity( + hostname: string, + cert: Partial, +): Error | undefined { + const subject = cert.subject; + const altNames = cert.subjectaltname; + const dnsNames: string[] = []; + const ips: string[] = []; + + // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion + hostname = "" + hostname; + + if (altNames) { + const splitAltNames = altNames.includes('"') + ? splitEscapedAltNames(altNames) + : altNames.split(", "); + splitAltNames.forEach((name) => { + if (name.startsWith("DNS:")) { + dnsNames.push(name.slice(4)); + } else if (name.startsWith("IP Address:")) { + ips.push(urlUtil.canonicalizeIp(name.slice(11))); + } + }); + } + + let valid = false; + let reason = "Unknown reason"; + + hostname = unfqdn(hostname); // Remove trailing dot for error messages. + + if (isIP(hostname)) { + valid = ips.includes(urlUtil.canonicalizeIp(hostname)); + if (!valid) + reason = `IP: ${hostname} is not in the cert's list: ` + ips.join(", "); + } else if (dnsNames.length > 0 || subject?.CN) { + const hostParts = splitHost(hostname); + const wildcard = (pattern: string): boolean => + check(hostParts, pattern, true); + + if (dnsNames.length > 0) { + valid = dnsNames.some(wildcard); + if (!valid) + reason = `Host: ${hostname}. is not in the cert's altnames: ${altNames}`; + } else { + // Match against Common Name only if no supported identifiers exist. + const cn = subject?.CN; + + if (Array.isArray(cn)) valid = cn.some(wildcard); + else if (cn) valid = wildcard(cn); + + if (!valid) reason = `Host: ${hostname}. is not cert's CN: ${cn}`; + } + } else { + reason = "Cert does not contain a DNS name"; + } + + if (!valid) { + return new ERR_TLS_CERT_ALTNAME_INVALID(reason, hostname, cert); + } + return undefined; +} + +// Convert protocols array into valid OpenSSL protocols list +// ("\x06spdy/2\x08http/1.1\x08http/1.0") +function convertProtocols(protocols: string[]): Buffer { + const lens = Array.from({ length: protocols.length }, () => 0); + const buff = Buffer.allocUnsafe( + protocols.reduce((p, c, i) => { + const len = Buffer.byteLength(c); + if (len > 255) { + throw new ERR_OUT_OF_RANGE( + "The byte length of the protocol at index " + + `${i} exceeds the maximum length.`, + "<= 255", + len, + true, + ); + } + lens[i] = len; + return p + 1 + len; + }, 0), + ); + + let offset = 0; + for (let i = 0, c = protocols.length; i < c; i++) { + buff[offset++] = lens[i] as number; + buff.write(protocols[i] as string, offset); + offset += lens[i] as number; + } + + return buff; +} + +export function convertALPNProtocols( + protocols: unknown, + out: { + ALPNProtocols: Buffer; + }, +): void { + // If protocols is Array - translate it into buffer + if (Array.isArray(protocols)) { + out.ALPNProtocols = convertProtocols(protocols as string[]); + } else if (isUint8Array(protocols)) { + // Copy new buffer not to be modified by user. + out.ALPNProtocols = Buffer.from(protocols); + } else if (isArrayBufferView(protocols)) { + out.ALPNProtocols = Buffer.from( + protocols.buffer.slice( + protocols.byteOffset, + protocols.byteOffset + protocols.byteLength, + ), + ); + } +} + +export function createServer(): void { + throw new Error("Not implemented"); +} + +export function Server(): void { + throw new Error("Not implemented"); +} + +export function getCiphers(): void { + throw new Error("Not implemented"); +} diff --git a/src/compat/tls/index.ts b/src/compat/tls/index.ts new file mode 100644 index 00000000..abe66449 --- /dev/null +++ b/src/compat/tls/index.ts @@ -0,0 +1,73 @@ +// @ts-nocheck +import { Buffer } from "node:buffer"; +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +import { + checkServerIdentity, + convertALPNProtocols, + createServer, + Server, + getCiphers, +} from "./helpers.js"; +import { createSecureContext, SecureContext } from "../tls-common/index.js"; +import * as constants from "./constants.js"; +import { TLSSocket, connect } from "./wrap.js"; +import { ERR_METHOD_NOT_IMPLEMENTED } from "./errors.js"; + +let createSecurePair = undefined; + +if (true) { + createSecurePair = function createSecurePair(): void { + throw new ERR_METHOD_NOT_IMPLEMENTED("createSecurePair"); + }; +} + +export * from "./constants.js"; +export { + TLSSocket, + connect, + createSecureContext, + createServer, + checkServerIdentity, + SecureContext, + Server, + convertALPNProtocols, + getCiphers, + createSecurePair, +}; +export default { + SecureContext, + Server, + TLSSocket, + connect, + createSecureContext, + createServer, + checkServerIdentity, + convertALPNProtocols, + getCiphers, + createSecurePair, + ...constants, +}; diff --git a/src/compat/tls/jsstream.ts b/src/compat/tls/jsstream.ts new file mode 100644 index 00000000..752401b9 --- /dev/null +++ b/src/compat/tls/jsstream.ts @@ -0,0 +1,221 @@ +// @ts-nocheck +import { Buffer } from "node:buffer"; +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +/* eslint-disable @typescript-eslint/no-redundant-type-constituents */ + +import { notStrictEqual } from "../assert/index.js"; +import { Socket } from "../net/internal-net.js"; +import { ERR_STREAM_WRAP } from "./errors.js"; +import { Duplex, toBYOBWeb } from "../stream/duplex.js"; +import type { + SocketInfo, + Writer, + Socket as CloudflareSocket, +} from "node-internal:sockets"; + +const kCurrentWriteRequest = Symbol("kCurrentWriteRequest"); +const kCurrentShutdownRequest = Symbol("kCurrentShutdownRequest"); +const kPendingShutdownRequest = Symbol("kPendingShutdownRequest"); +const kPendingClose = Symbol("kPendingClose"); + +/* This class serves as a wrapper for when the C++ side of Node wants access + * to a standard JS stream. For example, TLS or HTTP do not operate on network + * resources conceptually, although that is the common case and what we are + * optimizing for; in theory, they are completely composable and can work with + * any stream resource they see. + * + * For the common case, i.e. a TLS socket wrapping around a net.Socket, we + * can skip going through the JS layer and let TLS access the raw C++ handle + * of a net.Socket. The flipside of this is that, to maintain composability, + * we need a way to create "fake" net.Socket instances that call back into a + * "real" JavaScript stream. JSStreamSocket is exactly this. + */ +export class JSStreamSocket extends Socket { + stream: Duplex; + [kCurrentWriteRequest]: null | unknown; + [kCurrentShutdownRequest]: null | unknown; + [kPendingShutdownRequest]: null | unknown; + [kPendingClose]: boolean; + + constructor(stream: Duplex) { + // eslint-disable-next-line @typescript-eslint/no-invalid-void-type + const closePromise = Promise.withResolvers(); + const openPromise = Promise.withResolvers(); + + const webStream = toBYOBWeb(stream); + Object.assign(webStream.writable, { + // eslint-disable-next-line @typescript-eslint/require-await + write: async (data: string | ArrayBufferView): Promise => { + stream.write(data); + }, + closed: closePromise.promise, + releaseLock: async (): Promise => {}, + }); + const handle: Socket["_handle"] = { + reading: true, + bytesRead: 0, + bytesWritten: 0, + socket: { + startTls(): CloudflareSocket { + throw new Error( + "startTls() should not be called for a duplex stream", + ); + }, + upgraded: false, + secureTransport: "off", + closed: closePromise.promise, + close: async (): Promise => { + queueMicrotask(() => { + closePromise.resolve(); + }); + return closePromise.promise; + }, + opened: openPromise.promise, + readable: webStream.readable, + writable: webStream.writable as unknown as Writer, + }, + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + reader: new ReadableStreamBYOBReader(webStream.readable), + writer: new WritableStreamDefaultWriter(webStream.writable), + options: { + host: "0.0.0.0", + port: 0, + addressType: 4, + }, + }; + + stream.pause(); + stream.on("error", (err) => this.emit("error", err)); + const ondata = (chunk: string | Buffer): void => { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare + if (typeof chunk === "string" || stream.readableObjectMode === true) { + // Make sure that no further `data` events will happen. + stream.pause(); + stream.removeListener("data", ondata); + + this.emit("error", new ERR_STREAM_WRAP()); + return; + } + + // TODO(soon): We need to trigger read() result for _handle.reader.read(buf) call + // in node:net. + }; + stream.on("data", ondata); + stream.once("end", () => { + closePromise.resolve(); + }); + // Some `Stream` don't pass `hasError` parameters when closed. + stream.once("close", () => { + // Errors emitted from `stream` have also been emitted to this instance + // so that we don't pass errors to `destroy()` again. + this.destroy(); + }); + + super({ handle }); + this.stream = stream; + this[kCurrentWriteRequest] = null; + this[kCurrentShutdownRequest] = null; + this[kPendingShutdownRequest] = null; + this[kPendingClose] = false; + this.readable = stream.readable; + this.writable = stream.writable; + + // eslint-disable-next-line @typescript-eslint/no-floating-promises + handle.socket.closed.then(this.doClose.bind(this)); + + openPromise.resolve({}); + + // Start reading. + this.read(0); + } + + isClosing(): boolean { + return !this.readable || !this.writable; + } + + readStart(): number { + this.stream.resume(); + return 0; + } + + readStop(): number { + this.stream.pause(); + return 0; + } + + doShutdown(req: unknown): number { + // TODO(addaleax): It might be nice if we could get into a state where + // DoShutdown() is not called on streams while a write is still pending. + // + // Currently, the only part of the code base where that happens is the + // TLS implementation, which calls both DoWrite() and DoShutdown() on the + // underlying network stream inside of its own DoShutdown() method. + // Working around that on the native side is not quite trivial (yet?), + // so for now that is supported here. + + if (this[kCurrentWriteRequest] !== null) { + this[kPendingShutdownRequest] = req; + return 0; + } + + this[kCurrentShutdownRequest] = req; + + if (this[kPendingClose]) { + // If doClose is pending, the stream & this._handle are gone. We can't do + // anything. doClose will call finishShutdown with ECANCELED for us shortly. + return 0; + } + + const handle = this._handle; + notStrictEqual(handle, null); + + queueMicrotask(() => { + // Ensure that write is dispatched asynchronously. + this.stream.end(); + }); + return 0; + } + + doClose(): void { + this[kPendingClose] = true; + + const handle = this._handle; + + // When sockets of the "net" module destroyed, they will call + // `this._handle.close()` which will also emit EOF if not emitted before. + // This feature makes sockets on the other side emit "end" and "close" + // even though we haven't called `end()`. As `stream` are likely to be + // instances of `net.Socket`, calling `stream.destroy()` manually will + // avoid issues that don't properly close wrapped connections. + this.stream.destroy(); + + queueMicrotask(() => { + notStrictEqual(handle, null); + this[kPendingClose] = false; + }); + } +} diff --git a/src/compat/tls/upgrade.spec.ts b/src/compat/tls/upgrade.spec.ts new file mode 100644 index 00000000..620a822b --- /dev/null +++ b/src/compat/tls/upgrade.spec.ts @@ -0,0 +1,55 @@ +import { afterEach, expect, it, vi } from "vitest"; +import { connect as tcp, Socket } from "../net/index.js"; +import { connect, TLSSocket } from "./index.js"; +import { + setNativeCall, + type NativeCall, +} from "../../browser/fetch/native-network.js"; +let restore: (() => void) | undefined; +afterEach(() => { + restore?.(); + restore = undefined; +}); +it("rejects TLS wrapping before application bytes can reach a plain socket", async () => { + const call = vi.fn(async (_, method) => + method === "socketRead" || method === "socketWatch" + ? new Promise(() => {}) + : {}, + ); + restore = setNativeCall(call); + const plain = tcp({ host: "localhost", port: 1234 }); + plain.on("error", () => {}); + try { + await new Promise((resolve, reject) => { + plain.once("connect", resolve); + plain.once("error", reject); + }); + expect(() => + connect({ socket: plain, servername: "localhost" }).write("secret-data"), + ).toThrow(/TLS upgrade of an existing socket/); + expect(() => new TLSSocket(plain, { port: 1234 })).toThrow( + expect.objectContaining({ code: "ERR_METHOD_NOT_IMPLEMENTED" }), + ); + expect( + call.mock.calls.filter(([, method]) => method === "socketOpen"), + ).toHaveLength(1); + expect(call.mock.calls.some(([, method]) => method === "socketWrite")).toBe( + false, + ); + expect(plain.destroyed).toBe(false); + } finally { + plain.destroy(); + } +}); +it("rejects wrapping an unconnected socket before acquiring its handles", () => { + const socket = new Socket(); + try { + expect(() => connect({ socket })).toThrow( + /TLS upgrade of an existing socket/, + ); + expect(socket.listenerCount("connect")).toBe(0); + expect(socket.destroyed).toBe(false); + } finally { + socket.destroy(); + } +}); diff --git a/src/compat/tls/wrap.ts b/src/compat/tls/wrap.ts new file mode 100644 index 00000000..990b459e --- /dev/null +++ b/src/compat/tls/wrap.ts @@ -0,0 +1,793 @@ +// @ts-nocheck +import { ERR_INVALID_ARG_TYPE } from "../net/errors.js"; +import { isArrayBufferView } from "../util/types/index.js"; +function validateBuffer(value: unknown, name: string) { + if (!isArrayBufferView(value)) + throw new ERR_INVALID_ARG_TYPE( + name, + ["Buffer", "TypedArray", "DataView"], + value, + ); +} +import { Buffer } from "node:buffer"; +import { socketReader } from "../net/reader.js"; +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +import { + Socket, + type SocketOptions, + _normalizeArgs, + onConnectionOpened, + onConnectionClosed, + tryReadStart, +} from "../net/internal-net.js"; +import { JSStreamSocket } from "./jsstream.js"; +import type { + ConnectionOptions, + TlsOptions, + TLSSocket as TLSSocketType, +} from "node:tls"; +import type { Duplex } from "../stream/duplex.js"; +import type { OnReadOpts, TcpSocketConnectOpts } from "node:net"; +import { + validateString, + validateObject, + validateNumber, + validateFunction, + validateInt32, + validateUint32, +} from "../net/validators.js"; +import { + ConnResetException, + ERR_TLS_HANDSHAKE_TIMEOUT, + ERR_OPTION_NOT_IMPLEMENTED, + ERR_TLS_INVALID_CONTEXT, + ERR_METHOD_NOT_IMPLEMENTED, +} from "./errors.js"; +import { SecureContext } from "../tls-common/index.js"; +const processImpl = { shouldThrowOnNotImplementedTlsOption: () => true }; +import { ok } from "../assert/index.js"; + +const kConnectOptions = Symbol("connect-options"); +const kErrorEmitted = Symbol("error-emitted"); +const kRes = Symbol("res"); +const kPendingSession = Symbol("pendingSession"); +const kIsVerified = Symbol("verified"); + +// @ts-expect-error TS2323 Cannot redeclare error. +export declare class TLSSocket extends Socket { + _hadError: boolean; + _handle: Socket["_handle"]; + _init(): void; + _tlsOptions: TlsOptions & + ConnectionOptions & + SocketOptions & + TcpSocketConnectOpts & { + isServer?: boolean; + requestOCSP?: boolean; + server?: unknown; + onread?: OnReadOpts; + }; + _secureEstablished: boolean; + _securePending: boolean; + _newSessionPending: boolean; + _controlReleased: boolean; + authorized: boolean; + encrypted: boolean; + handle: ReturnType; + servername: null | string; + secureConnecting: boolean; + ssl: TLSSocket["_handle"]; + [kRes]: null | Socket["_handle"]; + [kIsVerified]: boolean; + [kPendingSession]: null | Buffer; + [kErrorEmitted]: boolean; + [kConnectOptions]?: NormalizedConnectionOptions; + + constructor( + socket: Socket | Duplex | undefined, + opts: TLSSocket["_tlsOptions"], + ); + prototype: TLSSocket; + + _destroySSL(): void; + _emitTLSError(error: Error): void; + _finishInit(): void; + _handleTimeout(): void; + _releaseControl(): boolean; + _start(): void; + _tlsError(error: Error): Error | null; + _wrapHandle( + wrap: null | Socket, + handle: Socket["_handle"] | null | undefined, + wrapHasActiveWriteFromPrevOwner: boolean, + ): unknown; + disableRenegotiation(): void; + getX509Certificate(): ReturnType; + setKeyCert(context: unknown): void; + setServername(name: string): void; + setSession(session: string | Buffer): void; + setMaxSendFragment(size: number): boolean; + getCertificate(): ReturnType; + getPeerX509Certificate(): ReturnType; + renegotiate( + options: { + rejectUnauthorized?: boolean | undefined; + requestCert?: boolean | undefined; + }, + callback?: (error: Error | null) => void, + ): boolean; + exportKeyingMaterial(length: number, label: string, context?: Buffer): Buffer; +} + +function onnewsessionclient( + this: TLSSocket, + _sessionId: string, + session: Buffer, +): void { + if (this[kIsVerified]) { + this.emit("session", session); + } else { + this[kPendingSession] = session; + } +} + +function onerror(this: TLSSocket, err: Error): void { + if (this._hadError) return; + + this._hadError = true; + + // Destroy socket if error happened before handshake's finish + if (!this._secureEstablished) { + // When handshake fails control is not yet released, + // so self._tlsError will return null instead of actual error + + // Set closing the socket after emitting an event since the socket needs to + // be accessible when the `tlsClientError` event is emitted. + this.destroy(err); + } else { + // Emit error + this._emitTLSError(err); + } +} + +// We are using old style function classes for node.js compat. +// @ts-expect-error TS2323 Cannot redeclare error. +export function TLSSocket( + this: TLSSocket, + socket: Socket | Duplex | undefined, + opts: TLSSocket["_tlsOptions"], +): void { + const tlsOptions = { ...opts }; + + if (tlsOptions.enableTrace) { + throw new ERR_OPTION_NOT_IMPLEMENTED("options.enableTrace"); + } + + if (tlsOptions.isServer) { + throw new ERR_OPTION_NOT_IMPLEMENTED("options.isServer"); + } + + if (tlsOptions.server) { + throw new ERR_OPTION_NOT_IMPLEMENTED("options.server"); + } + + if (tlsOptions.requestCert) { + // Servers will request certificate from clients. + // Does not apply to Cloudflare Workers. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.requestCert"); + } + + if (tlsOptions.rejectUnauthorized === false) { + // TODO(soon): We don't support rejectUnauthorized=false + throw new ERR_OPTION_NOT_IMPLEMENTED("options.rejectUnauthorized"); + } + + if (tlsOptions.ALPNProtocols !== undefined) { + // Does not apply to Cloudflare Workers. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.ALPNProtocols"); + } + + if (tlsOptions.SNICallback !== undefined) { + // Does not apply to Cloudflare Workers. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.SNICallback"); + } + + if (tlsOptions.requestOCSP) { + // Not yet supported. Can be implemented in the future. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.requestOCSP"); + } + + if ( + tlsOptions.secureContext !== undefined && + !(tlsOptions.secureContext instanceof SecureContext) + ) { + throw new ERR_TLS_INVALID_CONTEXT("context"); + } + + if (tlsOptions.pskCallback !== undefined) { + // Used for TLS-PSK negotiation. We do not support it. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.pskCallback"); + } + + // checkServerIdentity requires access to the peer certificate via + // getPeerCertificate(), which is not yet implemented. When the + // throw_on_not_implemented_tls_options compat flag is enabled we throw; + // otherwise we silently continue so that existing workers are not broken. + if (tlsOptions.checkServerIdentity !== undefined) { + validateFunction( + tlsOptions.checkServerIdentity, + "options.checkServerIdentity", + ); + if (processImpl.shouldThrowOnNotImplementedTlsOption()) { + throw new ERR_OPTION_NOT_IMPLEMENTED("options.checkServerIdentity"); + } + } + + // Native transports cannot upgrade an already-open connection yet. Reject + // before taking ownership of its writer: marking a plain socket encrypted + // without a handshake would allow TLS application data onto the wire as text. + if (socket != null) { + throw new ERR_METHOD_NOT_IMPLEMENTED("TLS upgrade of an existing socket"); + } + + this._tlsOptions = tlsOptions; + this._secureEstablished = false; + this._securePending = false; + this._newSessionPending = false; + this._controlReleased = false; + this.secureConnecting = true; + this.servername = tlsOptions.servername ?? null; + this.authorized = false; + this[kRes] = null; + this[kIsVerified] = false; + this[kPendingSession] = null; + this[kErrorEmitted] = false; + + let wrap: Socket | null = null; + let handle: Socket["_handle"] | null = null; + let wrapHasActiveWriteFromPrevOwner = false; + + if (socket) { + if (socket instanceof Socket) { + wrap = socket; + } else { + wrap = new JSStreamSocket(socket); + } + + handle = wrap._handle; + wrapHasActiveWriteFromPrevOwner = wrap.writableLength > 0; + } + + // Just a documented property to make secure sockets + // distinguishable from regular ones. + this.encrypted = true; + + Reflect.apply(Socket, this, [ + { + handle: this._wrapHandle(wrap, handle, wrapHasActiveWriteFromPrevOwner), + allowHalfOpen: socket ? socket.allowHalfOpen : tlsOptions.allowHalfOpen, + pauseOnCreate: tlsOptions.pauseOnConnect, + manualStart: true, + highWaterMark: tlsOptions.highWaterMark, + onread: !socket ? tlsOptions.onread : null, + signal: tlsOptions.signal, + lookup: tlsOptions.lookup, + } as SocketOptions, + ]); + + this._parent = handle; + this._parentWrap = wrap; + + // Proxy for API compatibility + this.ssl = this._handle; // C++ TLSWrap object + + this.on("error", this._tlsError.bind(this)); + + this._init(); +} +Object.setPrototypeOf(TLSSocket.prototype, Socket.prototype); +Object.setPrototypeOf(TLSSocket, Socket); + +TLSSocket.prototype.disableRenegotiation = function disableRenegotiation( + this: TLSSocket, +): void { + // Do nothing. +}; + +TLSSocket.prototype._wrapHandle = function _wrapHandle( + this: TLSSocket, + wrap: null | Socket, + handle: Socket["_handle"] | null | undefined, + _wrapHasActiveWriteFromPrevOwner: boolean, +): unknown { + if (!handle) { + return null; + } + this[kRes] = handle; + + // Guard against adding multiple listeners, as this method may be called + // repeatedly on the same socket by reinitializeHandle + if (this.listenerCount("close", onSocketCloseDestroySSL) === 0) { + this.once("close", onSocketCloseDestroySSL); + } + + wrap?.once("close", () => this.destroy()); + + return handle; +}; + +function onSocketCloseDestroySSL(this: TLSSocket): void { + // We call destroySSL directly because it is already an async process. + this._destroySSL(); + this[kRes] = null; +} + +TLSSocket.prototype._destroySSL = function _destroySSL(this: TLSSocket): void { + // We disable floating promises rule because we don't want to change the + // function signature and return Promise + // + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this._handle?.socket.close().then(() => { + this[kPendingSession] = null; + this[kIsVerified] = false; + }); +}; + +TLSSocket.prototype._init = function _init(this: TLSSocket): void { + const options = this._tlsOptions; + + this.on("error", onerror.bind(this)); + + // This is emitted from net.Socket class. + this.on("connectionAttempt", onnewsessionclient.bind(this)); + + if (options.handshakeTimeout && options.handshakeTimeout > 0) + this.setTimeout(options.handshakeTimeout, this._handleTimeout.bind(this)); + + // TLSSocket can be initialized with 2 different handles. + // + // 1. Socket instance created by "node:net". In this scenario, we need + // to wait for 'connect' event to be emitted in order to trigger _finishInit(). + // 2. Duplex stream. Duplex streams are initialized through JSStreamSocket class. + // If that's the scenario, we can trigger _finishInit() immediately. Since, there + // is no async calls required to wait. + if (this._parentWrap != null && this._parentWrap instanceof JSStreamSocket) { + queueMicrotask(() => { + this._finishInit(); + ok(this._parentWrap instanceof JSStreamSocket); + this._parentWrap.readStart(); + tryReadStart(this); + }); + } else { + this.on("connect", () => { + this._finishInit(); + }); + } +}; + +TLSSocket.prototype.renegotiate = function ( + this: TLSSocket, + options: { + rejectUnauthorized?: boolean | undefined; + requestCert?: boolean | undefined; + }, + callback?: (error: Error | null) => void, +): boolean { + validateObject(options, "options"); + if (callback !== undefined) { + validateFunction(callback, "callback"); + } + // TLS renegotiation is not supported. + return false; +}; + +TLSSocket.prototype.exportKeyingMaterial = function exportKeyingMaterial( + this: TLSSocket, + length: number, + label: string, + context?: Buffer, +): Buffer { + validateUint32(length, "length", true); + validateString(label, "label"); + if (context !== undefined) { + validateBuffer(context, "context"); + } + + throw new Error("exportKeyingMaterial is not implemented"); +}; + +TLSSocket.prototype.setMaxSendFragment = function setMaxSendFragment( + this: TLSSocket, + size: number, +): boolean { + validateInt32(size, "size"); + // Setting maximum TLS fragment size is not supported. + return false; +}; + +TLSSocket.prototype._handleTimeout = function _handleTimeout( + this: TLSSocket, +): void { + this._emitTLSError(new ERR_TLS_HANDSHAKE_TIMEOUT()); +}; + +TLSSocket.prototype._emitTLSError = function _emitTLSError( + this: TLSSocket, + err: Error, +): void { + const e = this._tlsError(err); + if (e) this.emit("error", e); +}; + +TLSSocket.prototype._tlsError = function _tlsError( + this: TLSSocket, + err: Error, +): Error | null { + this.emit("_tlsError", err); + if (this._controlReleased) return err; + return null; +}; + +TLSSocket.prototype._releaseControl = function _releaseControl( + this: TLSSocket, +): boolean { + if (this._controlReleased) return false; + this._controlReleased = true; + this.removeListener("error", this._tlsError.bind(this)); + return true; +}; + +// This function is called from net.Socket onConnectionOpened() handler. +TLSSocket.prototype._finishInit = function _finishInit(this: TLSSocket): void { + // Guard against getting onhandshakedone() after .destroy(). + // * 1.2: If destroy() during onocspresponse(), then write of next handshake + // record fails, the handshake done info callbacks does not occur, and the + // socket closes. + // * 1.3: The OCSP response comes in the same record that finishes handshake, + // so even after .destroy(), the handshake done info callback occurs + // immediately after onocspresponse(). Ignore it. + if (!this._handle) return; + + this._secureEstablished = true; + if ( + this._tlsOptions.handshakeTimeout && + this._tlsOptions.handshakeTimeout > 0 + ) { + this.setTimeout(0, this._handleTimeout.bind(this)); + } + + this.emit("secure"); +}; + +TLSSocket.prototype._start = function _start(this: TLSSocket): void { + if (this.connecting) { + this.once("connect", this._start.bind(this)); + return; + } + + // If a user calls tls.connect({ socket }) with a socket that is not initialized + // and the socket is not connected, we need to wait for the socket to connect + // before we can complete the process. + // + // Take a look at the following test for this particular edge case: + // https://github.com/nodejs/node/blob/91d8a524ada001103a2d1c6825ca17b8393c183f/test/parallel/test-tls-on-empty-socket.js + if (this._parentWrap != null && this._parentWrap._handle == null) { + this._parentWrap.once("connect", () => { + // We need to update the Socket handle of this TLSSocket + // since it was created after TLSSocket is initialized. + if (this._parentWrap?._handle != null) { + this._handle = this._parentWrap._handle; + } + this._start(); + }); + return; + } + + // Guard against the following cases: + // - Socket was destroyed before the connection was established + // - TLSSocket can not be upgraded if the secureTransport does not support 'starttls' + if (this._handle?.socket.secureTransport !== "starttls") { + return; + } + + // The connection moves to a new handle: the read loop's pending read on + // this one is about to reject, which it must not take for a failure. + this._handle.handedOver = true; + this._handle.writer.releaseLock(); + this._handle.reader.releaseLock(); + + try { + const { host, port, addressType } = this._handle.options; + const tlsOpts = + this.servername != null + ? { expectedServerHostname: this.servername } + : undefined; + const socket = this._handle.socket.startTls(tlsOpts); + + this._handle = { + socket: socket, + writer: socket.writable.getWriter(), + reader: socketReader(socket.readable), + bytesRead: 0, + bytesWritten: 0, + reading: true, + options: this._handle.options, + }; + + // This is now an encrypted connection. + // There are cases where in node:net we have to distinguish between + // encrypted and unencrypted connections. + this.encrypted = true; + + this._handle.socket.opened.then( + onConnectionOpened.bind(this), + (err: unknown) => { + this.emit("connectionAttemptFailed", host, port, addressType, err); + this.destroy(err as Error); + }, + ); + + this._handle.socket.closed.then( + onConnectionClosed.bind(this), + (error: unknown): void => { + // Do not call this.destroy.bind(this) since user can override it. + this.destroy(error as Error); + }, + ); + } catch (error) { + this.destroy(error as Error); + } +}; + +TLSSocket.prototype.setServername = function setServername( + this: TLSSocket, + name: string, +): void { + validateString(name, "name"); + this.servername = name; +}; + +TLSSocket.prototype.setSession = function (_session: string | Buffer): void { + // Do nothing. We don't support setting session. +}; + +// @ts-expect-error TS2322 Inconsistencies between @types/node +TLSSocket.prototype.getPeerCertificate = function ( + _detailed?: boolean, +): ReturnType { + // Returns an object representing a peer certificate. + // This function is not supported. + throw new Error("getPeerCertificate is not implemented"); +}; + +TLSSocket.prototype.getCertificate = function ( + this: TLSSocket, +): ReturnType { + // Returns an object representing the local certificate. + // This function is not supported. + throw new Error("TLSSocket.getCertificate is not implemented"); +}; + +TLSSocket.prototype.getPeerX509Certificate = function ( + this: TLSSocket, + _detailed?: boolean, +): ReturnType { + // Returns the peer certificate as an X509 certificate. + // This function is not supported. + throw new Error("TLSSocket.getPeerX509Certificate is not implemented"); +}; + +TLSSocket.prototype.getX509Certificate = function ( + this: TLSSocket, +): ReturnType { + // Returns the local certificate as an X509 certificate. + // This function is not supported. + throw new Error("TLSSocket.getX509Certificate is not implemented"); +}; + +TLSSocket.prototype.setKeyCert = function ( + this: TLSSocket, + _context: unknown, +): void { + // Changing private key and certificate to be used with TCP connection + // is not supported due to the limitations of connect() api. + throw new Error("TLSSocket.setKeyCert is not implemented"); +}; + +// We have this syntax because of the original Node.js implementation. +// They are not supported by Cloudflare Workers but in Node.js +// they are all properties of this._handle[PROP_NAME] +[ + "getCipher", + "getSharedSigalgs", + "getEphemeralKeyInfo", + "getFinished", + "getPeerFinished", + "getProtocol", + "getSession", + "getTLSTicket", + "isSessionReused", + "enableTrace", +].forEach((method) => { + // @ts-expect-error TS7053 Omitting... + TLSSocket.prototype[method] = function (): null { + // None of these functions are supported by connect() api. + return null; + }; +}); + +type NormalizedConnectionOptions = ConnectionOptions & + SocketOptions & + TlsOptions & { + host?: string; + port: number; + }; +function normalizeConnectArgs( + listArgs: unknown[], +): [NormalizedConnectionOptions] | [NormalizedConnectionOptions, VoidFunction] { + const args = _normalizeArgs(listArgs); + const options = args[0] as NormalizedConnectionOptions; + const cb = args[1] as VoidFunction | undefined; + + // If args[0] was options, then normalize dealt with it. + // If args[0] is port, or args[0], args[1] is host, port, we need to + // find the options and merge them in, normalize's options has only + // the host/port/path args that it knows about, not the tls options. + // This means that options.host overrides a host arg. + if (listArgs[1] !== null && typeof listArgs[1] === "object") { + Object.assign(options, listArgs[1]); + } else if (listArgs[2] !== null && typeof listArgs[2] === "object") { + Object.assign(options, listArgs[2]); + } + + return cb ? [options, cb] : [options]; +} + +function onConnectSecure(this: TLSSocket): void { + this.authorized = true; + this.secureConnecting = false; + this.emit("secureConnect"); + + this[kIsVerified] = true; + const session = this[kPendingSession]; + this[kPendingSession] = null; + if (session) this.emit("session", session); + + this.removeListener("end", onConnectEnd); +} + +function onConnectEnd(this: TLSSocket): void { + // NOTE: This logic is shared with _http_client.js + if (!this._hadError) { + const options = this[kConnectOptions]; + this._hadError = true; + const error = new ConnResetException( + "Client network socket disconnected " + + "before secure TLS connection was " + + "established", + ); + error.path = options?.path; + error.host = options?.host; + error.port = options?.port; + // @ts-expect-error TS2339 Missing types + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + error.localAddress = options?.localAddress; + this.destroy(error); + } +} + +// Arguments: [port,] [host,] [options,] [cb] +export function connect(...args: unknown[]): TLSSocket { + args = normalizeConnectArgs(args); + const options = args[0] as NormalizedConnectionOptions; + const cb = args[1] as VoidFunction | undefined; + + if (options.minDHSize !== undefined) { + // We leave this validation for node.js compat. + validateNumber(options.minDHSize, "options.minDHSize", 1); + // Not supported. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.minDHSize"); + } + + if (options.rejectUnauthorized === false) { + // TODO(soon): We don't support rejectUnauthorized=false + throw new ERR_OPTION_NOT_IMPLEMENTED("options.rejectUnauthorized"); + } + + if (options.pskCallback !== undefined) { + // Used for TLS-PSK negotiation. + // Does not make sense for Cloudflare Workers. + throw new ERR_OPTION_NOT_IMPLEMENTED("options.pskCallback"); + } + + if (options.checkServerIdentity !== undefined) { + validateFunction( + options.checkServerIdentity, + "options.checkServerIdentity", + ); + if (processImpl.shouldThrowOnNotImplementedTlsOption()) { + throw new ERR_OPTION_NOT_IMPLEMENTED("options.checkServerIdentity"); + } + } + + // @ts-expect-error TS2345 Type incompatibility between Node.js Duplex and internal Duplex + const tlssock = new TLSSocket(options.socket, { + allowHalfOpen: options.allowHalfOpen, + pipe: !!options.path, + ALPNProtocols: options.ALPNProtocols, + enableTrace: options.enableTrace, + highWaterMark: options.highWaterMark, + secureContext: options.secureContext, + onread: options.onread, + signal: options.signal, + lookup: options.lookup, + rejectUnauthorized: + options.rejectUnauthorized !== undefined + ? Boolean(options.rejectUnauthorized) // eslint-disable-line @typescript-eslint/no-unnecessary-type-conversion + : true, + }); + + tlssock[kConnectOptions] = options; + + // In Node.js, servername defaults to options.host when not explicitly set. + // Store it on the TLSSocket so _start() can pass it as expectedServerHostname + // to the native Socket.startTls() call for correct TLS certificate identity + // validation. + if (options.servername !== undefined) { + tlssock.servername = options.servername; + } + + if (cb) { + tlssock.once("secureConnect", cb); + } + + if (!options.socket) { + // If user provided the socket, it's their responsibility to manage its + // connectivity. If we created one internally, we connect it. + if (options.timeout) { + tlssock.setTimeout(options.timeout); + } + + tlssock.connect(options, tlssock._start.bind(tlssock)); + } + + tlssock._releaseControl(); + + if (options.session) { + tlssock.setSession(options.session); + } + + if (options.socket) { + tlssock._start(); + } + + // The 'secure' event is emitted by the SecurePair object once a secure connection has been established. + tlssock.on("secure", onConnectSecure); + tlssock.prependListener("end", onConnectEnd); + + return tlssock; +} diff --git a/src/compat/util/index.ts b/src/compat/util/index.ts index 8546f72b..fcbd2359 100644 --- a/src/compat/util/index.ts +++ b/src/compat/util/index.ts @@ -1,3 +1,4 @@ +import { isKeyObject } from "../crypto/key-state.js"; import { debuglog } from "./debuglog.js"; import { inspect, @@ -23,7 +24,49 @@ export * from "./core.js"; // @ts-expect-error the polyfill ships CJS without declarations import util from "util/util.js"; import { Buffer } from "node:buffer"; -export const types = util.types; +export const types = Object.assign(util.types, { + isKeyObject, + isDate(value: unknown) { + try { + Date.prototype.getTime.call(value); + return true; + } catch { + return false; + } + }, + isRegExp(value: unknown) { + try { + Object.getOwnPropertyDescriptor(RegExp.prototype, "source")!.get!.call( + value, + ); + return true; + } catch { + return false; + } + }, + isNativeError(value: unknown) { + return typeof (Error as any).isError === "function" + ? (Error as any).isError(value) + : value instanceof Error; + }, + isCryptoKey(value: unknown) { + try { + const ctor = globalThis.CryptoKey; + if (!ctor) return false; + Object.getOwnPropertyDescriptor(ctor.prototype, "type")!.get!.call(value); + return true; + } catch { + return false; + } + }, + isFloat16Array(value: unknown) { + const getTag = Object.getOwnPropertyDescriptor( + Object.getPrototypeOf(Uint8Array.prototype), + Symbol.toStringTag, + )!.get!; + return getTag.call(value) === "Float16Array"; + }, +}); export const isArray = Array.isArray; export const isBoolean = (val: unknown): boolean => typeof val === "boolean"; export const isBuffer = (val: unknown): boolean => Buffer.isBuffer(val); diff --git a/src/compat/util/types/index.ts b/src/compat/util/types/index.ts new file mode 100644 index 00000000..f242f0ea --- /dev/null +++ b/src/compat/util/types/index.ts @@ -0,0 +1,49 @@ +// The same types object is shared by util and util/types. Engine-only +// predicates retain the explicit limitations of the dependency adapter. +import { types } from "../index.js"; +export default types; +export const { + isDate, + isKeyObject, + isRegExp, + isNativeError, + isCryptoKey, + isFloat16Array, + isArgumentsObject, + isGeneratorFunction, + isTypedArray, + isPromise, + isArrayBufferView, + isUint8Array, + isUint8ClampedArray, + isUint16Array, + isUint32Array, + isInt8Array, + isInt16Array, + isInt32Array, + isFloat32Array, + isFloat64Array, + isBigInt64Array, + isBigUint64Array, + isMap, + isSet, + isWeakMap, + isWeakSet, + isArrayBuffer, + isDataView, + isSharedArrayBuffer, + isAsyncFunction, + isMapIterator, + isSetIterator, + isGeneratorObject, + isNumberObject, + isStringObject, + isBooleanObject, + isBigIntObject, + isSymbolObject, + isBoxedPrimitive, + isAnyArrayBuffer, + isProxy, + isExternal, + isModuleNamespaceObject, +} = types; diff --git a/src/compat/zlib/LICENSE.brotli b/src/compat/zlib/LICENSE.brotli new file mode 100644 index 00000000..33b7cdd2 --- /dev/null +++ b/src/compat/zlib/LICENSE.brotli @@ -0,0 +1,19 @@ +Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/src/compat/zlib/LICENSE.emscripten b/src/compat/zlib/LICENSE.emscripten new file mode 100644 index 00000000..70cabe38 --- /dev/null +++ b/src/compat/zlib/LICENSE.emscripten @@ -0,0 +1,102 @@ +Emscripten is available under 2 licenses, the MIT license and the +University of Illinois/NCSA Open Source License. + +Both are permissive open source licenses, with little if any +practical difference between them. + +The reason for offering both is that (1) the MIT license is +well-known, while (2) the University of Illinois/NCSA Open Source +License allows Emscripten's code to be integrated upstream into +LLVM, which uses that license, should the opportunity arise. + +The full text of both licenses follows. + +============================================================================== + +Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +============================================================================== + +Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal with the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + + Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimers. + + Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimers + in the documentation and/or other materials provided with the + distribution. + + Neither the names of Mozilla, + nor the names of its contributors may be used to endorse + or promote products derived from this Software without specific prior + written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE. + +============================================================================== + +This program uses portions of Node.js source code located in src/library_path.js, +in accordance with the terms of the MIT license. Node's license follows: + + """ + Copyright Joyent, Inc. and other Node contributors. All rights reserved. + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal in the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + IN THE SOFTWARE. + """ + +The musl libc project is bundled in this repo, and it has the MIT license, see +system/lib/libc/musl/COPYRIGHT + +The third_party/ subdirectory contains code with other licenses. None of it is +used by default, but certain options use it (e.g., the optional closure compiler +flag will run closure compiler from third_party/). + diff --git a/src/compat/zlib/LICENSE.musl b/src/compat/zlib/LICENSE.musl new file mode 100644 index 00000000..c1628e9a --- /dev/null +++ b/src/compat/zlib/LICENSE.musl @@ -0,0 +1,193 @@ +musl as a whole is licensed under the following standard MIT license: + +---------------------------------------------------------------------- +Copyright © 2005-2020 Rich Felker, et al. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +---------------------------------------------------------------------- + +Authors/contributors include: + +A. Wilcox +Ada Worcester +Alex Dowad +Alex Suykov +Alexander Monakov +Andre McCurdy +Andrew Kelley +Anthony G. Basile +Aric Belsito +Arvid Picciani +Bartosz Brachaczek +Benjamin Peterson +Bobby Bingham +Boris Brezillon +Brent Cook +Chris Spiegel +Clément Vasseur +Daniel Micay +Daniel Sabogal +Daurnimator +David Carlier +David Edelsohn +Denys Vlasenko +Dmitry Ivanov +Dmitry V. Levin +Drew DeVault +Emil Renner Berthing +Fangrui Song +Felix Fietkau +Felix Janda +Gianluca Anzolin +Hauke Mehrtens +He X +Hiltjo Posthuma +Isaac Dunham +Jaydeep Patil +Jens Gustedt +Jeremy Huntwork +Jo-Philipp Wich +Joakim Sindholt +John Spencer +Julien Ramseier +Justin Cormack +Kaarle Ritvanen +Khem Raj +Kylie McClain +Leah Neukirchen +Luca Barbato +Luka Perkov +M Farkas-Dyck (Strake) +Mahesh Bodapati +Markus Wichmann +Masanori Ogino +Michael Clark +Michael Forney +Mikhail Kremnyov +Natanael Copa +Nicholas J. Kain +orc +Pascal Cuoq +Patrick Oppenlander +Petr Hosek +Petr Skocik +Pierre Carrier +Reini Urban +Rich Felker +Richard Pennington +Ryan Fairfax +Samuel Holland +Segev Finer +Shiz +sin +Solar Designer +Stefan Kristiansson +Stefan O'Rear +Szabolcs Nagy +Timo Teräs +Trutz Behn +Valentin Ochs +Will Dietz +William Haddon +William Pitcock + +Portions of this software are derived from third-party works licensed +under terms compatible with the above MIT license: + +The TRE regular expression implementation (src/regex/reg* and +src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed +under a 2-clause BSD license (license text in the source files). The +included version has been heavily modified by Rich Felker in 2012, in +the interests of size, simplicity, and namespace cleanliness. + +Much of the math library code (src/math/* and src/complex/*) is +Copyright © 1993,2004 Sun Microsystems or +Copyright © 2003-2011 David Schultz or +Copyright © 2003-2009 Steven G. Kargl or +Copyright © 2003-2009 Bruce D. Evans or +Copyright © 2008 Stephen L. Moshier or +Copyright © 2017-2018 Arm Limited +and labelled as such in comments in the individual source files. All +have been licensed under extremely permissive terms. + +The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008 +The Android Open Source Project and is licensed under a two-clause BSD +license. It was taken from Bionic libc, used on Android. + +The AArch64 memcpy and memset code (src/string/aarch64/*) are +Copyright © 1999-2019, Arm Limited. + +The implementation of DES for crypt (src/crypt/crypt_des.c) is +Copyright © 1994 David Burren. It is licensed under a BSD license. + +The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was +originally written by Solar Designer and placed into the public +domain. The code also comes with a fallback permissive license for use +in jurisdictions that may not recognize the public domain. + +The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011 +Valentin Ochs and is licensed under an MIT-style license. + +The x86_64 port was written by Nicholas J. Kain and is licensed under +the standard MIT terms. + +The mips and microblaze ports were originally written by Richard +Pennington for use in the ellcc project. The original code was adapted +by Rich Felker for build system and code conventions during upstream +integration. It is licensed under the standard MIT terms. + +The mips64 port was contributed by Imagination Technologies and is +licensed under the standard MIT terms. + +The powerpc port was also originally written by Richard Pennington, +and later supplemented and integrated by John Spencer. It is licensed +under the standard MIT terms. + +All other files which have no copyright comments are original works +produced specifically for use as part of this library, written either +by Rich Felker, the main author of the library, or by one or more +contibutors listed above. Details on authorship of individual files +can be found in the git version control history of the project. The +omission of copyright and license comments in each file is in the +interest of source tree size. + +In addition, permission is hereby granted for all public header files +(include/* and arch/*/bits/*) and crt files intended to be linked into +applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit +the copyright notice and permission notice otherwise required by the +license, and to use these files without any requirement of +attribution. These files include substantial contributions from: + +Bobby Bingham +John Spencer +Nicholas J. Kain +Rich Felker +Richard Pennington +Stefan Kristiansson +Szabolcs Nagy + +all of whom have explicitly granted such permission. + +This file previously contained text expressing a belief that most of +the files covered by the above exception were sufficiently trivial not +to be subject to copyright, resulting in confusion over whether it +negated the permissions granted in the license. In the spirit of +permissive licensing, and of not having licensing issues being an +obstacle to adoption, that text has been removed. diff --git a/src/compat/zlib/LICENSE.zstd b/src/compat/zlib/LICENSE.zstd new file mode 100644 index 00000000..75800288 --- /dev/null +++ b/src/compat/zlib/LICENSE.zstd @@ -0,0 +1,30 @@ +BSD License + +For Zstandard software + +Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook, nor Meta, nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/compat/zlib/compression.ts b/src/compat/zlib/compression.ts new file mode 100644 index 00000000..ae37e328 --- /dev/null +++ b/src/compat/zlib/compression.ts @@ -0,0 +1,334 @@ +import { Buffer } from "node:buffer"; +import { Transform } from "node:stream"; +import { NativeCodec, type Kind } from "./native-codecs.js"; +import { validateFunction, validateObject } from "../net/validators.js"; +import { validateInteger } from "../crypto/validation.js"; +import { ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE } from "../net/errors.js"; +const flushMarker = Symbol("codec flush"); +function bytes(value: unknown): Uint8Array { + if (typeof value === "string") return Buffer.from(value); + if (ArrayBuffer.isView(value)) + return new Uint8Array(value.buffer, value.byteOffset, value.byteLength); + if (value instanceof ArrayBuffer) return new Uint8Array(value); + throw new ERR_INVALID_ARG_TYPE( + "buffer", + ["string", "Buffer", "TypedArray", "DataView", "ArrayBuffer"], + value, + ); +} +// Pinned workerd validators: NaN selects defaults; finite fractional values +// are accepted here and converted by the underlying buffer/codec operation. +function finite(value: unknown, name: string): value is number { + if (value === undefined || Number.isNaN(value)) return false; + if (typeof value !== "number") + throw new ERR_INVALID_ARG_TYPE(name, "number", value); + if (!Number.isFinite(value)) + throw new ERR_OUT_OF_RANGE(name, "a finite number", value); + return true; +} +function range( + value: unknown, + name: string, + low: number, + high: number, + fallback: number, +): number { + if (!finite(value, name)) return fallback; + if (value < low || value > high) + throw new ERR_OUT_OF_RANGE(name, `>= ${low} and <= ${high}`, value); + return value; +} +function settings(kind: Kind, encode: boolean, value: any = {}) { + if (value == null) value = {}; + validateObject(value, "options"); + const chunkSize = finite(value.chunkSize, "options.chunkSize") + ? value.chunkSize + : 16384; + if (chunkSize < 64) + throw new ERR_OUT_OF_RANGE("options.chunkSize", ">= 64", chunkSize); + const maxOutputLength = range( + value.maxOutputLength, + "options.maxOutputLength", + 1, + 2147483647, + 2147483647, + ); + const params = value.params ?? {}; + validateObject(params, "options.params"); + const maximum = kind === "brotli" ? 8 : encode ? 402 : 100; + const seen = new Set(); + for (const [key, val] of Object.entries(params)) { + const number = Number(key); + if ( + !Number.isInteger(number) || + number < 0 || + number > maximum || + seen.has(number) + ) + throw Object.assign( + new RangeError( + `${key} is not a valid ${kind === "brotli" ? "Brotli" : "Zstd"} parameter`, + ), + { + code: + kind === "brotli" + ? "ERR_BROTLI_INVALID_PARAM" + : "ERR_ZSTD_INVALID_PARAM", + }, + ); + seen.add(number); + if (typeof val !== "number" && typeof val !== "boolean") + throw new ERR_INVALID_ARG_TYPE("options.params[key]", "number", val); + } + const flush = range( + value.flush, + "options.flush", + 0, + kind === "brotli" ? 3 : 2, + 0, + ); + const finishFlush = range( + value.finishFlush, + "options.finishFlush", + 0, + kind === "brotli" ? 3 : 2, + 2, + ); + if (value.pledgedSrcSize !== undefined) + validateInteger( + value.pledgedSrcSize, + "options.pledgedSrcSize", + 0, + 0xffffffff, + ); + return { + chunkSize, + maxOutputLength, + params, + flush, + finishFlush, + pledged: value.pledgedSrcSize, + info: !!value.info, + }; +} +class CodecTransform extends Transform { + private codec: NativeCodec; + private readonly config: ReturnType; + bytesWritten = 0; + private readonly kind: Kind; + private readonly encode: boolean; + constructor(kind: Kind, encode: boolean, options?: any) { + const config = settings(kind, encode, options); + super(options ?? {}); + this.kind = kind; + this.encode = encode; + this.config = config; + this.codec = new NativeCodec( + kind, + encode, + config.chunkSize, + config.params, + config.pledged, + ); + } + _transform(input: any, _encoding: any, callback: any) { + try { + const operation = input[flushMarker] ?? this.config.flush; + this.codec.process(bytes(input), operation, (output) => + this.push(Buffer.from(output)), + ); + this.bytesWritten = this.codec.consumed; + callback(); + } catch (error) { + callback(error); + } + } + _flush(callback: any) { + try { + this.codec.process(new Uint8Array(), this.config.finishFlush, (output) => + this.push(Buffer.from(output)), + ); + this.bytesWritten = this.codec.consumed; + callback(); + } catch (error) { + callback(error); + } + } + _destroy(error: any, callback: any) { + this.codec.close(); + callback(error); + } + flush(kind?: number | (() => void), callback?: () => void) { + if (typeof kind === "function") { + callback = kind; + kind = 1; + } + kind ??= 1; + validateInteger(kind, "kind", 0, this.kind === "brotli" ? 3 : 2); + if (callback !== undefined) validateFunction(callback, "callback"); + if (this.writableFinished) { + if (callback) queueMicrotask(callback); + return; + } + const marker: any = Buffer.alloc(0); + marker[flushMarker] = kind; + this.write(marker, callback); + } + reset() { + if (this.destroyed) throw new Error("Codec is closed"); + this.codec.close(); + this.codec = new NativeCodec( + this.kind, + this.encode, + this.config.chunkSize, + this.config.params, + this.config.pledged, + ); + this.bytesWritten = 0; + } + close(callback?: () => void) { + if (callback) { + validateFunction(callback, "callback"); + this.once("close", callback); + } + this.destroy(); + } + _processChunk(input: unknown, operation = 2) { + const chunks: Uint8Array[] = []; + let length = 0; + try { + this.codec.process(bytes(input), operation, (output) => { + length += output.length; + if (length > this.config.maxOutputLength) + throw Object.assign( + new RangeError( + "Cannot create a Buffer larger than maxOutputLength", + ), + { code: "ERR_BUFFER_TOO_LARGE" }, + ); + chunks.push(output); + }); + this.bytesWritten = this.codec.consumed; + return Buffer.concat(chunks, length); + } finally { + this.codec.close(); + } + } +} +export class BrotliCompress extends CodecTransform { + constructor(options?: any) { + super("brotli", true, options); + } +} +export class BrotliDecompress extends CodecTransform { + constructor(options?: any) { + super("brotli", false, options); + } +} +export class ZstdCompress extends CodecTransform { + constructor(options?: any) { + super("zstd", true, options); + } +} +export class ZstdDecompress extends CodecTransform { + constructor(options?: any) { + super("zstd", false, options); + } +} +export const createBrotliCompress = (options?: any) => + new BrotliCompress(options); +export const createBrotliDecompress = (options?: any) => + new BrotliDecompress(options); +export const createZstdCompress = (options?: any) => new ZstdCompress(options); +export const createZstdDecompress = (options?: any) => + new ZstdDecompress(options); +function sync(kind: Kind, encode: boolean, input: unknown, options?: any) { + const data = bytes(input), + config = settings(kind, encode, options); + if (config.info) { + const Constructor = + kind === "brotli" + ? encode + ? BrotliCompress + : BrotliDecompress + : encode + ? ZstdCompress + : ZstdDecompress; + const engine = new Constructor(options); + return { buffer: engine._processChunk(data, config.finishFlush), engine }; + } + const codec = new NativeCodec( + kind, + encode, + config.chunkSize, + config.params, + config.pledged ?? (encode && kind === "zstd" ? data.length : undefined), + ); + const chunks: Uint8Array[] = []; + let length = 0; + try { + codec.process(data, config.finishFlush, (output) => { + length += output.length; + if (length > config.maxOutputLength) + throw new RangeError("Memory limit exceeded"); + chunks.push(output); + }); + return Buffer.concat(chunks, length); + } catch (error) { + if ( + error instanceof RangeError || + (error instanceof Error && error.message === "Unexpected end of file") + ) + throw error; + throw new Error("Compression failed"); + } finally { + codec.close(); + } +} +function asyncOperation( + kind: Kind, + encode: boolean, + input: unknown, + options: any, + callback?: any, +) { + if (typeof options === "function") { + callback = options; + options = undefined; + } + validateFunction(callback, "callback"); + const data = bytes(input); + settings(kind, encode, options); + new Promise((resolve) => resolve(sync(kind, encode, data, options))).then( + (result) => callback(null, result), + (error) => callback(error), + ); +} +export function brotliCompressSync(input: unknown, options?: any) { + return sync("brotli", true, input, options); +} +export function brotliDecompressSync(input: unknown, options?: any) { + return sync("brotli", false, input, options); +} +export function zstdCompressSync(input: unknown, options?: any) { + return sync("zstd", true, input, options); +} +export function zstdDecompressSync(input: unknown, options?: any) { + return sync("zstd", false, input, options); +} +export function brotliCompress(input: unknown, options?: any, callback?: any) { + asyncOperation("brotli", true, input, options, callback); +} +export function brotliDecompress( + input: unknown, + options?: any, + callback?: any, +) { + asyncOperation("brotli", false, input, options, callback); +} +export function zstdCompress(input: unknown, options?: any, callback?: any) { + asyncOperation("zstd", true, input, options, callback); +} +export function zstdDecompress(input: unknown, options?: any, callback?: any) { + asyncOperation("zstd", false, input, options, callback); +} diff --git a/src/compat/zlib/constants.ts b/src/compat/zlib/constants.ts new file mode 100644 index 00000000..e7e21fe4 --- /dev/null +++ b/src/compat/zlib/constants.ts @@ -0,0 +1,173 @@ +// Constants observed in workerd 1.20261012.1 (2026-10-17 profile). +export const Z_NO_FLUSH = 0; +export const Z_PARTIAL_FLUSH = 1; +export const Z_SYNC_FLUSH = 2; +export const Z_FULL_FLUSH = 3; +export const Z_FINISH = 4; +export const Z_BLOCK = 5; +export const Z_OK = 0; +export const Z_STREAM_END = 1; +export const Z_NEED_DICT = 2; +export const Z_ERRNO = -1; +export const Z_STREAM_ERROR = -2; +export const Z_DATA_ERROR = -3; +export const Z_MEM_ERROR = -4; +export const Z_BUF_ERROR = -5; +export const Z_VERSION_ERROR = -6; +export const Z_NO_COMPRESSION = 0; +export const Z_BEST_SPEED = 1; +export const Z_BEST_COMPRESSION = 9; +export const Z_DEFAULT_COMPRESSION = -1; +export const Z_FILTERED = 1; +export const Z_HUFFMAN_ONLY = 2; +export const Z_RLE = 3; +export const Z_FIXED = 4; +export const Z_DEFAULT_STRATEGY = 0; +export const ZLIB_VERNUM = 4897; +export const DEFLATE = 1; +export const INFLATE = 2; +export const GZIP = 3; +export const GUNZIP = 4; +export const DEFLATERAW = 5; +export const INFLATERAW = 6; +export const UNZIP = 7; +export const BROTLI_DECODE = 8; +export const BROTLI_ENCODE = 9; +export const Z_MIN_WINDOWBITS = 8; +export const Z_MAX_WINDOWBITS = 15; +export const Z_DEFAULT_WINDOWBITS = 15; +export const Z_MIN_CHUNK = 64; +export const Z_MAX_CHUNK = 134217728; +export const Z_DEFAULT_CHUNK = 16384; +export const Z_MIN_MEMLEVEL = 1; +export const Z_MAX_MEMLEVEL = 9; +export const Z_DEFAULT_MEMLEVEL = 8; +export const Z_MIN_LEVEL = -1; +export const Z_MAX_LEVEL = 9; +export const Z_DEFAULT_LEVEL = -1; +export const BROTLI_OPERATION_PROCESS = 0; +export const BROTLI_OPERATION_FLUSH = 1; +export const BROTLI_OPERATION_FINISH = 2; +export const BROTLI_OPERATION_EMIT_METADATA = 3; +export const BROTLI_PARAM_MODE = 0; +export const BROTLI_MODE_GENERIC = 0; +export const BROTLI_MODE_TEXT = 1; +export const BROTLI_MODE_FONT = 2; +export const BROTLI_DEFAULT_MODE = 0; +export const BROTLI_PARAM_QUALITY = 1; +export const BROTLI_MIN_QUALITY = 0; +export const BROTLI_MAX_QUALITY = 11; +export const BROTLI_DEFAULT_QUALITY = 11; +export const BROTLI_PARAM_LGWIN = 2; +export const BROTLI_MIN_WINDOW_BITS = 10; +export const BROTLI_MAX_WINDOW_BITS = 24; +export const BROTLI_LARGE_MAX_WINDOW_BITS = 30; +export const BROTLI_DEFAULT_WINDOW = 22; +export const BROTLI_PARAM_LGBLOCK = 3; +export const BROTLI_MIN_INPUT_BLOCK_BITS = 16; +export const BROTLI_MAX_INPUT_BLOCK_BITS = 24; +export const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING = 4; +export const BROTLI_PARAM_SIZE_HINT = 5; +export const BROTLI_PARAM_LARGE_WINDOW = 6; +export const BROTLI_PARAM_NPOSTFIX = 7; +export const BROTLI_PARAM_NDIRECT = 8; +export const BROTLI_DECODER_RESULT_ERROR = 0; +export const BROTLI_DECODER_RESULT_SUCCESS = 1; +export const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2; +export const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3; +export const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0; +export const BROTLI_DECODER_PARAM_LARGE_WINDOW = 1; +export const BROTLI_DECODER_NO_ERROR = 0; +export const BROTLI_DECODER_SUCCESS = 1; +export const BROTLI_DECODER_NEEDS_MORE_INPUT = 2; +export const BROTLI_DECODER_NEEDS_MORE_OUTPUT = 3; +export const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE = -1; +export const BROTLI_DECODER_ERROR_FORMAT_RESERVED = -2; +export const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE = -3; +export const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET = -4; +export const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME = -5; +export const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE = -6; +export const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE = -7; +export const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT = -8; +export const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 = -9; +export const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 = -10; +export const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM = -11; +export const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY = -12; +export const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS = -13; +export const BROTLI_DECODER_ERROR_FORMAT_PADDING_1 = -14; +export const BROTLI_DECODER_ERROR_FORMAT_PADDING_2 = -15; +export const BROTLI_DECODER_ERROR_FORMAT_DISTANCE = -16; +export const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET = -19; +export const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS = -20; +export const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES = -21; +export const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS = -22; +export const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP = -25; +export const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 = -26; +export const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 = -27; +export const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES = -30; +export const BROTLI_DECODER_ERROR_UNREACHABLE = -31; +export const ZSTD_ENCODE = 10; +export const ZSTD_DECODE = 11; +export const ZSTD_COMPRESS = 10; +export const ZSTD_DECOMPRESS = 11; +export const ZSTD_e_continue = 0; +export const ZSTD_e_flush = 1; +export const ZSTD_e_end = 2; +export const ZSTD_c_compressionLevel = 100; +export const ZSTD_c_windowLog = 101; +export const ZSTD_c_hashLog = 102; +export const ZSTD_c_chainLog = 103; +export const ZSTD_c_searchLog = 104; +export const ZSTD_c_minMatch = 105; +export const ZSTD_c_targetLength = 106; +export const ZSTD_c_strategy = 107; +export const ZSTD_c_enableLongDistanceMatching = 160; +export const ZSTD_c_ldmHashLog = 161; +export const ZSTD_c_ldmMinMatch = 162; +export const ZSTD_c_ldmBucketSizeLog = 163; +export const ZSTD_c_ldmHashRateLog = 164; +export const ZSTD_c_contentSizeFlag = 200; +export const ZSTD_c_checksumFlag = 201; +export const ZSTD_c_dictIDFlag = 202; +export const ZSTD_c_nbWorkers = 400; +export const ZSTD_c_jobSize = 401; +export const ZSTD_c_overlapLog = 402; +export const ZSTD_d_windowLogMax = 100; +export const ZSTD_fast = 1; +export const ZSTD_dfast = 2; +export const ZSTD_greedy = 3; +export const ZSTD_lazy = 4; +export const ZSTD_lazy2 = 5; +export const ZSTD_btlazy2 = 6; +export const ZSTD_btopt = 7; +export const ZSTD_btultra = 8; +export const ZSTD_btultra2 = 9; +export const ZSTD_CLEVEL_DEFAULT = 3; +export const ZSTD_error_no_error = 0; +export const ZSTD_error_GENERIC = 1; +export const ZSTD_error_prefix_unknown = 10; +export const ZSTD_error_version_unsupported = 12; +export const ZSTD_error_frameParameter_unsupported = 14; +export const ZSTD_error_frameParameter_windowTooLarge = 16; +export const ZSTD_error_corruption_detected = 20; +export const ZSTD_error_checksum_wrong = 22; +export const ZSTD_error_literals_headerWrong = 24; +export const ZSTD_error_dictionary_corrupted = 30; +export const ZSTD_error_dictionary_wrong = 32; +export const ZSTD_error_dictionaryCreation_failed = 34; +export const ZSTD_error_parameter_unsupported = 40; +export const ZSTD_error_parameter_combination_unsupported = 41; +export const ZSTD_error_parameter_outOfBound = 42; +export const ZSTD_error_tableLog_tooLarge = 44; +export const ZSTD_error_maxSymbolValue_tooLarge = 46; +export const ZSTD_error_maxSymbolValue_tooSmall = 48; +export const ZSTD_error_stabilityCondition_notRespected = 50; +export const ZSTD_error_stage_wrong = 60; +export const ZSTD_error_init_missing = 62; +export const ZSTD_error_memory_allocation = 64; +export const ZSTD_error_workSpace_tooSmall = 66; +export const ZSTD_error_dstSize_tooSmall = 70; +export const ZSTD_error_srcSize_wrong = 72; +export const ZSTD_error_dstBuffer_null = 74; +export const ZSTD_error_noForwardProgress_destFull = 80; +export const ZSTD_error_noForwardProgress_inputEmpty = 82; diff --git a/src/compat/zlib/index.ts b/src/compat/zlib/index.ts new file mode 100644 index 00000000..28e3c0ec --- /dev/null +++ b/src/compat/zlib/index.ts @@ -0,0 +1,398 @@ +import { Buffer } from "node:buffer"; +// @ts-expect-error browserify-zlib has no declarations +import original from "browserify-zlib/lib/index.js"; +import { validateInteger } from "../crypto/validation.js"; +import { ERR_INVALID_ARG_TYPE } from "../net/errors.js"; +import * as compression from "./compression.js"; +export * from "./compression.js"; +export const { + Zlib, + codes, + Deflate, + Inflate, + Gzip, + Gunzip, + DeflateRaw, + InflateRaw, + Unzip, + createDeflate, + createInflate, + createDeflateRaw, + createInflateRaw, + createGzip, + createGunzip, + createUnzip, + deflate, + deflateSync, + gzip, + gzipSync, + deflateRaw, + deflateRawSync, + unzip, + unzipSync, + inflate, + inflateSync, + gunzip, + gunzipSync, + inflateRaw, + inflateRawSync, +} = original; +import * as pinnedConstants from "./constants.js"; +const topLevelConstants = { + Z_NO_FLUSH: pinnedConstants.Z_NO_FLUSH, + Z_PARTIAL_FLUSH: pinnedConstants.Z_PARTIAL_FLUSH, + Z_SYNC_FLUSH: pinnedConstants.Z_SYNC_FLUSH, + Z_FULL_FLUSH: pinnedConstants.Z_FULL_FLUSH, + Z_FINISH: pinnedConstants.Z_FINISH, + Z_BLOCK: pinnedConstants.Z_BLOCK, + Z_OK: pinnedConstants.Z_OK, + Z_STREAM_END: pinnedConstants.Z_STREAM_END, + Z_NEED_DICT: pinnedConstants.Z_NEED_DICT, + Z_ERRNO: pinnedConstants.Z_ERRNO, + Z_STREAM_ERROR: pinnedConstants.Z_STREAM_ERROR, + Z_DATA_ERROR: pinnedConstants.Z_DATA_ERROR, + Z_MEM_ERROR: pinnedConstants.Z_MEM_ERROR, + Z_BUF_ERROR: pinnedConstants.Z_BUF_ERROR, + Z_VERSION_ERROR: pinnedConstants.Z_VERSION_ERROR, + Z_NO_COMPRESSION: pinnedConstants.Z_NO_COMPRESSION, + Z_BEST_SPEED: pinnedConstants.Z_BEST_SPEED, + Z_BEST_COMPRESSION: pinnedConstants.Z_BEST_COMPRESSION, + Z_DEFAULT_COMPRESSION: pinnedConstants.Z_DEFAULT_COMPRESSION, + Z_FILTERED: pinnedConstants.Z_FILTERED, + Z_HUFFMAN_ONLY: pinnedConstants.Z_HUFFMAN_ONLY, + Z_RLE: pinnedConstants.Z_RLE, + Z_FIXED: pinnedConstants.Z_FIXED, + Z_DEFAULT_STRATEGY: pinnedConstants.Z_DEFAULT_STRATEGY, + ZLIB_VERNUM: pinnedConstants.ZLIB_VERNUM, + DEFLATE: pinnedConstants.DEFLATE, + INFLATE: pinnedConstants.INFLATE, + GZIP: pinnedConstants.GZIP, + GUNZIP: pinnedConstants.GUNZIP, + DEFLATERAW: pinnedConstants.DEFLATERAW, + INFLATERAW: pinnedConstants.INFLATERAW, + UNZIP: pinnedConstants.UNZIP, + BROTLI_DECODE: pinnedConstants.BROTLI_DECODE, + BROTLI_ENCODE: pinnedConstants.BROTLI_ENCODE, + Z_MIN_WINDOWBITS: pinnedConstants.Z_MIN_WINDOWBITS, + Z_MAX_WINDOWBITS: pinnedConstants.Z_MAX_WINDOWBITS, + Z_DEFAULT_WINDOWBITS: pinnedConstants.Z_DEFAULT_WINDOWBITS, + Z_MIN_CHUNK: pinnedConstants.Z_MIN_CHUNK, + Z_MAX_CHUNK: pinnedConstants.Z_MAX_CHUNK, + Z_DEFAULT_CHUNK: pinnedConstants.Z_DEFAULT_CHUNK, + Z_MIN_MEMLEVEL: pinnedConstants.Z_MIN_MEMLEVEL, + Z_MAX_MEMLEVEL: pinnedConstants.Z_MAX_MEMLEVEL, + Z_DEFAULT_MEMLEVEL: pinnedConstants.Z_DEFAULT_MEMLEVEL, + Z_MIN_LEVEL: pinnedConstants.Z_MIN_LEVEL, + Z_MAX_LEVEL: pinnedConstants.Z_MAX_LEVEL, + Z_DEFAULT_LEVEL: pinnedConstants.Z_DEFAULT_LEVEL, + BROTLI_OPERATION_PROCESS: pinnedConstants.BROTLI_OPERATION_PROCESS, + BROTLI_OPERATION_FLUSH: pinnedConstants.BROTLI_OPERATION_FLUSH, + BROTLI_OPERATION_FINISH: pinnedConstants.BROTLI_OPERATION_FINISH, + BROTLI_OPERATION_EMIT_METADATA: + pinnedConstants.BROTLI_OPERATION_EMIT_METADATA, + BROTLI_PARAM_MODE: pinnedConstants.BROTLI_PARAM_MODE, + BROTLI_MODE_GENERIC: pinnedConstants.BROTLI_MODE_GENERIC, + BROTLI_MODE_TEXT: pinnedConstants.BROTLI_MODE_TEXT, + BROTLI_MODE_FONT: pinnedConstants.BROTLI_MODE_FONT, + BROTLI_DEFAULT_MODE: pinnedConstants.BROTLI_DEFAULT_MODE, + BROTLI_PARAM_QUALITY: pinnedConstants.BROTLI_PARAM_QUALITY, + BROTLI_MIN_QUALITY: pinnedConstants.BROTLI_MIN_QUALITY, + BROTLI_MAX_QUALITY: pinnedConstants.BROTLI_MAX_QUALITY, + BROTLI_DEFAULT_QUALITY: pinnedConstants.BROTLI_DEFAULT_QUALITY, + BROTLI_PARAM_LGWIN: pinnedConstants.BROTLI_PARAM_LGWIN, + BROTLI_MIN_WINDOW_BITS: pinnedConstants.BROTLI_MIN_WINDOW_BITS, + BROTLI_MAX_WINDOW_BITS: pinnedConstants.BROTLI_MAX_WINDOW_BITS, + BROTLI_LARGE_MAX_WINDOW_BITS: pinnedConstants.BROTLI_LARGE_MAX_WINDOW_BITS, + BROTLI_DEFAULT_WINDOW: pinnedConstants.BROTLI_DEFAULT_WINDOW, + BROTLI_PARAM_LGBLOCK: pinnedConstants.BROTLI_PARAM_LGBLOCK, + BROTLI_MIN_INPUT_BLOCK_BITS: pinnedConstants.BROTLI_MIN_INPUT_BLOCK_BITS, + BROTLI_MAX_INPUT_BLOCK_BITS: pinnedConstants.BROTLI_MAX_INPUT_BLOCK_BITS, + BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: + pinnedConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING, + BROTLI_PARAM_LARGE_WINDOW: pinnedConstants.BROTLI_PARAM_LARGE_WINDOW, + BROTLI_PARAM_NPOSTFIX: pinnedConstants.BROTLI_PARAM_NPOSTFIX, + BROTLI_PARAM_NDIRECT: pinnedConstants.BROTLI_PARAM_NDIRECT, + BROTLI_DECODER_RESULT_ERROR: pinnedConstants.BROTLI_DECODER_RESULT_ERROR, + BROTLI_DECODER_RESULT_SUCCESS: pinnedConstants.BROTLI_DECODER_RESULT_SUCCESS, + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: + pinnedConstants.BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT, + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: + pinnedConstants.BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT, + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: + pinnedConstants.BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION, + BROTLI_DECODER_PARAM_LARGE_WINDOW: + pinnedConstants.BROTLI_DECODER_PARAM_LARGE_WINDOW, + BROTLI_DECODER_NO_ERROR: pinnedConstants.BROTLI_DECODER_NO_ERROR, + BROTLI_DECODER_SUCCESS: pinnedConstants.BROTLI_DECODER_SUCCESS, + BROTLI_DECODER_NEEDS_MORE_INPUT: + pinnedConstants.BROTLI_DECODER_NEEDS_MORE_INPUT, + BROTLI_DECODER_NEEDS_MORE_OUTPUT: + pinnedConstants.BROTLI_DECODER_NEEDS_MORE_OUTPUT, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE, + BROTLI_DECODER_ERROR_FORMAT_RESERVED: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_RESERVED, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME, + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_CL_SPACE, + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE, + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2, + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_TRANSFORM, + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_DICTIONARY, + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS, + BROTLI_DECODER_ERROR_FORMAT_PADDING_1: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_PADDING_1, + BROTLI_DECODER_ERROR_FORMAT_PADDING_2: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_PADDING_2, + BROTLI_DECODER_ERROR_FORMAT_DISTANCE: + pinnedConstants.BROTLI_DECODER_ERROR_FORMAT_DISTANCE, + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: + pinnedConstants.BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET, + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: + pinnedConstants.BROTLI_DECODER_ERROR_INVALID_ARGUMENTS, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: + pinnedConstants.BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES, + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: + pinnedConstants.BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: + pinnedConstants.BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: + pinnedConstants.BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: + pinnedConstants.BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2, + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: + pinnedConstants.BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES, + BROTLI_DECODER_ERROR_UNREACHABLE: + pinnedConstants.BROTLI_DECODER_ERROR_UNREACHABLE, + ZSTD_ENCODE: pinnedConstants.ZSTD_ENCODE, + ZSTD_DECODE: pinnedConstants.ZSTD_DECODE, + ZSTD_COMPRESS: pinnedConstants.ZSTD_COMPRESS, + ZSTD_DECOMPRESS: pinnedConstants.ZSTD_DECOMPRESS, + ZSTD_error_no_error: pinnedConstants.ZSTD_error_no_error, + ZSTD_error_GENERIC: pinnedConstants.ZSTD_error_GENERIC, + ZSTD_error_prefix_unknown: pinnedConstants.ZSTD_error_prefix_unknown, + ZSTD_error_version_unsupported: + pinnedConstants.ZSTD_error_version_unsupported, + ZSTD_error_frameParameter_unsupported: + pinnedConstants.ZSTD_error_frameParameter_unsupported, + ZSTD_error_frameParameter_windowTooLarge: + pinnedConstants.ZSTD_error_frameParameter_windowTooLarge, + ZSTD_error_corruption_detected: + pinnedConstants.ZSTD_error_corruption_detected, + ZSTD_error_checksum_wrong: pinnedConstants.ZSTD_error_checksum_wrong, + ZSTD_error_literals_headerWrong: + pinnedConstants.ZSTD_error_literals_headerWrong, + ZSTD_error_dictionary_corrupted: + pinnedConstants.ZSTD_error_dictionary_corrupted, + ZSTD_error_dictionary_wrong: pinnedConstants.ZSTD_error_dictionary_wrong, + ZSTD_error_dictionaryCreation_failed: + pinnedConstants.ZSTD_error_dictionaryCreation_failed, + ZSTD_error_parameter_unsupported: + pinnedConstants.ZSTD_error_parameter_unsupported, + ZSTD_error_parameter_combination_unsupported: + pinnedConstants.ZSTD_error_parameter_combination_unsupported, + ZSTD_error_parameter_outOfBound: + pinnedConstants.ZSTD_error_parameter_outOfBound, + ZSTD_error_tableLog_tooLarge: pinnedConstants.ZSTD_error_tableLog_tooLarge, + ZSTD_error_maxSymbolValue_tooLarge: + pinnedConstants.ZSTD_error_maxSymbolValue_tooLarge, + ZSTD_error_maxSymbolValue_tooSmall: + pinnedConstants.ZSTD_error_maxSymbolValue_tooSmall, + ZSTD_error_stabilityCondition_notRespected: + pinnedConstants.ZSTD_error_stabilityCondition_notRespected, + ZSTD_error_stage_wrong: pinnedConstants.ZSTD_error_stage_wrong, + ZSTD_error_init_missing: pinnedConstants.ZSTD_error_init_missing, + ZSTD_error_memory_allocation: pinnedConstants.ZSTD_error_memory_allocation, + ZSTD_error_workSpace_tooSmall: pinnedConstants.ZSTD_error_workSpace_tooSmall, + ZSTD_error_dstSize_tooSmall: pinnedConstants.ZSTD_error_dstSize_tooSmall, + ZSTD_error_srcSize_wrong: pinnedConstants.ZSTD_error_srcSize_wrong, + ZSTD_error_dstBuffer_null: pinnedConstants.ZSTD_error_dstBuffer_null, + ZSTD_error_noForwardProgress_destFull: + pinnedConstants.ZSTD_error_noForwardProgress_destFull, + ZSTD_error_noForwardProgress_inputEmpty: + pinnedConstants.ZSTD_error_noForwardProgress_inputEmpty, +}; +export const { + Z_NO_FLUSH, + Z_PARTIAL_FLUSH, + Z_SYNC_FLUSH, + Z_FULL_FLUSH, + Z_FINISH, + Z_BLOCK, + Z_OK, + Z_STREAM_END, + Z_NEED_DICT, + Z_ERRNO, + Z_STREAM_ERROR, + Z_DATA_ERROR, + Z_MEM_ERROR, + Z_BUF_ERROR, + Z_VERSION_ERROR, + Z_NO_COMPRESSION, + Z_BEST_SPEED, + Z_BEST_COMPRESSION, + Z_DEFAULT_COMPRESSION, + Z_FILTERED, + Z_HUFFMAN_ONLY, + Z_RLE, + Z_FIXED, + Z_DEFAULT_STRATEGY, + ZLIB_VERNUM, + DEFLATE, + INFLATE, + GZIP, + GUNZIP, + DEFLATERAW, + INFLATERAW, + UNZIP, + BROTLI_DECODE, + BROTLI_ENCODE, + Z_MIN_WINDOWBITS, + Z_MAX_WINDOWBITS, + Z_DEFAULT_WINDOWBITS, + Z_MIN_CHUNK, + Z_MAX_CHUNK, + Z_DEFAULT_CHUNK, + Z_MIN_MEMLEVEL, + Z_MAX_MEMLEVEL, + Z_DEFAULT_MEMLEVEL, + Z_MIN_LEVEL, + Z_MAX_LEVEL, + Z_DEFAULT_LEVEL, + BROTLI_OPERATION_PROCESS, + BROTLI_OPERATION_FLUSH, + BROTLI_OPERATION_FINISH, + BROTLI_OPERATION_EMIT_METADATA, + BROTLI_PARAM_MODE, + BROTLI_MODE_GENERIC, + BROTLI_MODE_TEXT, + BROTLI_MODE_FONT, + BROTLI_DEFAULT_MODE, + BROTLI_PARAM_QUALITY, + BROTLI_MIN_QUALITY, + BROTLI_MAX_QUALITY, + BROTLI_DEFAULT_QUALITY, + BROTLI_PARAM_LGWIN, + BROTLI_MIN_WINDOW_BITS, + BROTLI_MAX_WINDOW_BITS, + BROTLI_LARGE_MAX_WINDOW_BITS, + BROTLI_DEFAULT_WINDOW, + BROTLI_PARAM_LGBLOCK, + BROTLI_MIN_INPUT_BLOCK_BITS, + BROTLI_MAX_INPUT_BLOCK_BITS, + BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING, + BROTLI_PARAM_LARGE_WINDOW, + BROTLI_PARAM_NPOSTFIX, + BROTLI_PARAM_NDIRECT, + BROTLI_DECODER_RESULT_ERROR, + BROTLI_DECODER_RESULT_SUCCESS, + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT, + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT, + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION, + BROTLI_DECODER_PARAM_LARGE_WINDOW, + BROTLI_DECODER_NO_ERROR, + BROTLI_DECODER_SUCCESS, + BROTLI_DECODER_NEEDS_MORE_INPUT, + BROTLI_DECODER_NEEDS_MORE_OUTPUT, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE, + BROTLI_DECODER_ERROR_FORMAT_RESERVED, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME, + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE, + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE, + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2, + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM, + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY, + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS, + BROTLI_DECODER_ERROR_FORMAT_PADDING_1, + BROTLI_DECODER_ERROR_FORMAT_PADDING_2, + BROTLI_DECODER_ERROR_FORMAT_DISTANCE, + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET, + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES, + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2, + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES, + BROTLI_DECODER_ERROR_UNREACHABLE, + ZSTD_ENCODE, + ZSTD_DECODE, + ZSTD_COMPRESS, + ZSTD_DECOMPRESS, + ZSTD_error_no_error, + ZSTD_error_GENERIC, + ZSTD_error_prefix_unknown, + ZSTD_error_version_unsupported, + ZSTD_error_frameParameter_unsupported, + ZSTD_error_frameParameter_windowTooLarge, + ZSTD_error_corruption_detected, + ZSTD_error_checksum_wrong, + ZSTD_error_literals_headerWrong, + ZSTD_error_dictionary_corrupted, + ZSTD_error_dictionary_wrong, + ZSTD_error_dictionaryCreation_failed, + ZSTD_error_parameter_unsupported, + ZSTD_error_parameter_combination_unsupported, + ZSTD_error_parameter_outOfBound, + ZSTD_error_tableLog_tooLarge, + ZSTD_error_maxSymbolValue_tooLarge, + ZSTD_error_maxSymbolValue_tooSmall, + ZSTD_error_stabilityCondition_notRespected, + ZSTD_error_stage_wrong, + ZSTD_error_init_missing, + ZSTD_error_memory_allocation, + ZSTD_error_workSpace_tooSmall, + ZSTD_error_dstSize_tooSmall, + ZSTD_error_srcSize_wrong, + ZSTD_error_dstBuffer_null, + ZSTD_error_noForwardProgress_destFull, + ZSTD_error_noForwardProgress_inputEmpty, +} = topLevelConstants; +export const constants = Object.freeze({ ...pinnedConstants }); + +function data(input: unknown): Uint8Array { + if (typeof input === "string") return Buffer.from(input); + if (ArrayBuffer.isView(input)) + return new Uint8Array(input.buffer, input.byteOffset, input.byteLength); + if (input instanceof ArrayBuffer) return new Uint8Array(input); + throw new ERR_INVALID_ARG_TYPE( + "buffer", + ["string", "Buffer", "TypedArray", "DataView", "ArrayBuffer"], + input, + ); +} +export function crc32(input: unknown, value = 0): number { + validateInteger(value, "value", 0, 0xffffffff); + let crc = value ^ -1; + for (const byte of data(input)) { + crc ^= byte; + for (let bit = 0; bit < 8; bit++) + crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0); + } + return (crc ^ -1) >>> 0; +} +export default { + ...original, + ...topLevelConstants, + constants, + ...compression, + crc32, +}; diff --git a/src/compat/zlib/native-codecs.build.json b/src/compat/zlib/native-codecs.build.json new file mode 100644 index 00000000..2d4d5d2d --- /dev/null +++ b/src/compat/zlib/native-codecs.build.json @@ -0,0 +1,8 @@ +{ + "revisions": { + "emsdk": "e4fe26ef59168ff44f4c23c466e497bf60b3411e", + "zstd": "f8745da6ff1ad1e7bab384bd1f9d742439278e99", + "brotli": "ed738e842d2fbdf2d6459e39267a633c4a9b2f5d" + }, + "sha256": "52f2d0edcc0193e5289a0e9b945e2b1a2de8b6ea3efadf11ebd60b88c53d11a4" +} diff --git a/src/compat/zlib/native-codecs.c b/src/compat/zlib/native-codecs.c new file mode 100644 index 00000000..eb9bc829 --- /dev/null +++ b/src/compat/zlib/native-codecs.c @@ -0,0 +1,45 @@ +// Thin bindings to the pinned upstream codecs; see build-native-codecs.mjs. +#include +#include +#include +#include +#include +#include +#define API EMSCRIPTEN_KEEPALIVE + +API void* z_create(int encode) { return encode ? (void*)ZSTD_createCCtx() : (void*)ZSTD_createDCtx(); } +API void z_free(void* ctx, int encode) { if (encode) ZSTD_freeCCtx(ctx); else ZSTD_freeDCtx(ctx); } +API size_t z_param(void* ctx, int encode, int id, int value) { + return encode ? ZSTD_CCtx_setParameter(ctx, (ZSTD_cParameter)id, value) : ZSTD_DCtx_setParameter(ctx, (ZSTD_dParameter)id, value); +} +API size_t z_reset(void* ctx, int encode) { + return encode ? ZSTD_CCtx_reset(ctx, ZSTD_reset_session_only) : ZSTD_DCtx_reset(ctx, ZSTD_reset_session_only); +} +API size_t z_process(void* ctx, int encode, const void* src, size_t len, void* dst, size_t capacity, int operation, uint32_t* state) { + ZSTD_inBuffer in = { src, len, 0 }; + ZSTD_outBuffer out = { dst, capacity, 0 }; + size_t result = encode ? ZSTD_compressStream2(ctx, &out, &in, (ZSTD_EndDirective)operation) : ZSTD_decompressStream(ctx, &out, &in); + state[0] = in.pos; state[1] = out.pos; + return result; +} +API int z_is_error(size_t code) { return ZSTD_isError(code); } +API const char* z_error(size_t code) { return ZSTD_getErrorName(code); } +API size_t z_size(void* ctx, uint32_t length) { return ZSTD_CCtx_setPledgedSrcSize(ctx, length); } + +API void* b_create(int encode) { return encode ? (void*)BrotliEncoderCreateInstance(NULL, NULL, NULL) : (void*)BrotliDecoderCreateInstance(NULL, NULL, NULL); } +API void b_free(void* ctx, int encode) { if (encode) BrotliEncoderDestroyInstance(ctx); else BrotliDecoderDestroyInstance(ctx); } +API int b_param(void* ctx, int encode, int id, uint32_t value) { + return encode ? BrotliEncoderSetParameter(ctx, (BrotliEncoderParameter)id, value) : BrotliDecoderSetParameter(ctx, (BrotliDecoderParameter)id, value); +} +API int b_process(void* ctx, int encode, const uint8_t* src, size_t len, uint8_t* dst, size_t capacity, int operation, uint32_t* state) { + size_t available_in = len, available_out = capacity; + int result; + if (encode) { + result = BrotliEncoderCompressStream(ctx, (BrotliEncoderOperation)operation, &available_in, &src, &available_out, &dst, NULL); + if (result) result = BrotliEncoderIsFinished(ctx) ? 1 : BrotliEncoderHasMoreOutput(ctx) ? 3 : 2; + } else result = BrotliDecoderDecompressStream(ctx, &available_in, &src, &available_out, &dst, NULL); + state[0] = len - available_in; state[1] = capacity - available_out; + return result; +} +API int b_error(void* ctx) { return BrotliDecoderGetErrorCode(ctx); } +API const char* b_error_string(int code) { return BrotliDecoderErrorString((BrotliDecoderErrorCode)code); } diff --git a/src/compat/zlib/native-codecs.ts b/src/compat/zlib/native-codecs.ts new file mode 100644 index 00000000..f4b2acff --- /dev/null +++ b/src/compat/zlib/native-codecs.ts @@ -0,0 +1,163 @@ +import binary from "./native-codecs.wasm"; +type API = Record number> & { + memory: WebAssembly.Memory; +}; +let api: API | undefined; +function library(): API { + if (!api) { + const module = new WebAssembly.Module(binary as BufferSource); + api = new WebAssembly.Instance(module, { + env: { emscripten_notify_memory_growth() {} }, + wasi_snapshot_preview1: { + proc_exit(code: number) { + throw new Error(`Codec exited: ${code}`); + }, + fd_write() { + return 8; + }, + }, + }).exports as unknown as API; + api._initialize(); + } + return api; +} +function string(api: API, pointer: number) { + const bytes = new Uint8Array(api.memory.buffer); + let end = pointer; + while (bytes[end]) end++; + return new TextDecoder().decode(bytes.subarray(pointer, end)); +} +export type Kind = "brotli" | "zstd"; +export class NativeCodec { + private api = library(); + private ctx: number; + private state: number; + private output: number; + private closed = false; + finished = false; + consumed = 0; + constructor( + readonly kind: Kind, + readonly encode: boolean, + readonly chunkSize: number, + params: Record, + pledged?: number, + ) { + const api = this.api; + this.ctx = (kind === "brotli" ? api.b_create : api.z_create)(+encode); + this.state = api.malloc(8); + this.output = api.malloc(chunkSize); + if (!this.ctx || !this.state || !this.output) { + this.close(); + throw new RangeError("Memory limit exceeded"); + } + try { + for (const [key, value] of Object.entries(params)) { + const result = (kind === "brotli" ? api.b_param : api.z_param)( + this.ctx, + +encode, + +key, + Number(value), + ); + if (kind === "brotli" ? !result : api.z_is_error(result)) + throw Object.assign(new Error("Initialization failed"), { + code: "ERR_ZLIB_INITIALIZATION_FAILED", + }); + } + if (pledged !== undefined && kind === "zstd" && encode) + this.zcheck(api.z_size(this.ctx, pledged)); + } catch (error) { + this.close(); + throw error; + } + } + private zcheck(result: number) { + if (this.api.z_is_error(result)) { + const message = string(this.api, this.api.z_error(result)); + throw Object.assign(new Error(message), { + code: "ZSTD_ERROR", + errno: result | 0, + }); + } + } + process( + input: Uint8Array, + operation: number, + emit: (bytes: Uint8Array) => void, + ): void { + if (this.closed) throw new Error("Codec is closed"); + if ( + this.finished && + (this.kind === "brotli" || (!this.encode && input.length === 0)) + ) + return; + const api = this.api; + const pointer = api.malloc(Math.max(1, input.byteLength)); + if (!pointer) throw new RangeError("Memory limit exceeded"); + new Uint8Array(api.memory.buffer).set(input, pointer); + let offset = 0; + try { + for (;;) { + const result = (this.kind === "brotli" ? api.b_process : api.z_process)( + this.ctx, + +this.encode, + pointer + offset, + input.length - offset, + this.output, + this.chunkSize, + operation, + this.state, + ); + const state = new Uint32Array(api.memory.buffer, this.state, 2); + const consumed = state[0], + produced = state[1]; + offset += consumed; + this.consumed += consumed; + if (this.kind === "zstd") this.zcheck(result); + else if (!result) { + const errno = this.encode ? 0 : api.b_error(this.ctx); + const code = this.encode + ? "ERR_BROTLI_COMPRESSION_FAILED" + : "ERR_" + string(api, api.b_error_string(errno)); + throw Object.assign(new Error("Compression failed"), { code, errno }); + } + if (produced) + emit( + new Uint8Array(api.memory.buffer, this.output, produced).slice(), + ); + this.finished = this.kind === "brotli" ? result === 1 : result === 0; + if ( + !this.encode && + this.finished && + (this.kind === "brotli" || offset === input.length) + ) + break; + if (this.encode && operation !== 0 && this.finished) break; + if (offset === input.length && produced < this.chunkSize) { + if (this.encode && operation === 2 && !this.finished) { + if (!consumed && !produced) + throw new Error("Codec made no progress"); + continue; + } + if (!this.encode && operation === 2 && !this.finished) + throw new Error("Unexpected end of file"); + break; + } + if (!consumed && !produced) throw new Error("Codec made no progress"); + } + } finally { + api.free(pointer); + } + } + close(): void { + if (this.closed) return; + this.closed = true; + if (this.ctx) + (this.kind === "brotli" ? this.api.b_free : this.api.z_free)( + this.ctx, + +this.encode, + ); + if (this.state) this.api.free(this.state); + if (this.output) this.api.free(this.output); + } +} diff --git a/src/compat/zlib/native-codecs.wasm b/src/compat/zlib/native-codecs.wasm new file mode 100755 index 0000000000000000000000000000000000000000..a3cdd9c7348a548a8eb6674be22058f083980283 GIT binary patch literal 1181723 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

aSDy}0~gTE2y0uHPq7EbnW6R`w7m|isl#tlUn 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

{=q7iZk|N&U`CdDp%leo1?Zsw7-XP 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 z x86`&@fRC4WAwj&5xW_vyvF~w~(}vNn`0zLrw#gKTk? z{c0p~gBI7%8mc3Hph=1%eahTXa6YoDAG3$`Mc-gItIc>1|5E~doGLyZl{KajBcdU5 z8fOP5;-H*}hjL=wIdO;S%-xJL>(ZI?hYNl`W>?%4vPD3RS*Zo8C1i6 z!fzXpL*k&Ybc?tjw`u$Edpu(AxrDz%_gfGTC3f41$>BFk`ft>RVb^Rz_y5CLwi0vu zGyRBS+)%B-}jsc|3yB+(1#`P_&f0DoW+Z5 zHhCT;MoJJPML#$LpeL$eN9ysy(~;ZH?Sjd*fRz) zhli;5#@-pkSZX1+&(Is&*duxYF37kEe(8R;ARvwM9`=kN_O3|aI5330`z!XOG~P+< zl#CT3c1jRCg)K|WALno4rr@uNPT&j*ABmgdp21o4MJE$0C5V+0#7f~CnIS$yS3SUQ zxD6R>V$C5=$F9vm7xcy#_Ahg@3H_F6Q&2dek&)A)_=*uxAHJf>G<4*if#@?B;?q+luK7T>{lOX;HJ~)Za zoQ(!Ct{FfF`nw#zVGCrd3HKyh0DbO8(I3_iJ{WWr`{w7&*&X^+!kD%L5Aj>`dm8N! zP?deZoT-F+avNvkJmS(EiBl-lHnU!D!I$go*~Cu?ozHIchnOeg6g7SgsS(HIjNib4 zxcEG5EAD+6pC@t}&OJ?4`d6KP>G9ibv5j`{-cEoweQAl^kxHHmk0Q9oc#V$l$y`5Y zUa{xZuGSp&Hn!(#`0T`(R`QPfjORMO&TRY#jaW}xYz3V4tk`lk;xrW*8@C&M5^T#+ z_1|o4X8n&x57n{Y4~3tX;jKzPti0zFu@ zZKT~1om-$)r{Bay3F4x#&+X!>%|Q?og-^&4-A6n-HWD#W#Iy0+1Nur#lvsxS+JHEb z9C&%%?oMpd4CcYg8O277Gd>f}mh3|OMlP3Flw9uQ`8^YM)?W6cE7Szru~Rv3mGb@r zz%kxi3-AFF@k!iZRW-wAk712z$dNB|v4y!fz+4<-?zb@a{>XnO^Ww>z^Z>lEpIUK_ zIHM@o==h(Ivudob#hhb0&@bYc_-z8`AjXJ)Nfap#!jCcPaVx|#3F4Xf{f3Jmo=M(` z4doq=_~u;XUcU?GHvs%Lz){OWSFA_oJ(1_`j9I^z*w6cJF%IIML^e87w^@mO62v|c zqwK=mPUAZ^;@qw3r=0V;vfn2Gf<5GW_%+*Z=bV>I{IXrW&VB6X*coTA1v;|tf5ds_ zTVgic@u&8~Z%C{jzc0mSh0XVjJ>_G*Ph1kG92I{t@p-0l=oEK!jJr0MxEWTv){^zV z0z0oaXAW#d4W9#NEW3u!LBr?3{#L;Gtw5WFFX>C})_Nhs#2g7?j)HDi7bRK)%`#<)9S@942= zFR^8MF)nxV*1$-7$BVdQ=>T-+w;R=o$!Y*F4t~Gk&Ny^v2fZ`^y?743eWWOqbBKww;=3zk{MjM}yW5R%5yK>iVd8gL ziXetbpqH>=odhvV{Eos!5W~bN(2cW;J8RHG0x?WTO?mwn>imwFI7{q|0M^rw%q8|Y zX9=tP&GA}0zmrBTqR?M;kf(Is>1F2E>YT4US;MEW>mDMb{JvP*%3RJs-iKO=3&zfM zWgeO%r!K6K7VPhP*e6xE8S zg#Y~vXOC3mjJPGvepb#_>}l3qRDG zR$-nB(LFx{`+!4seshVgn!{c&7x)@j2rL4=1AYKD0y}`)j7$F=z!umRl*aiFo z><5kj$AII2uJcX-XMuCTMc@i>6}So91?~e6fJeY%;0f>)cmccwUIFib_rSl%)h__{ z8$5Qx7wp70ozS1y7r-IlFmMDo3g|lZIB){cW1>z0rvd)$0{Y`5e=~N0{337(_zk!W z{0`{9_qh)I0o(-c0Qzqi?*V@T_W|xq={LV!2mS({08fEuz;oaQ@Dg|hyax1mq_@C3 zKp)Eoe5IFJBfkSzfos5Z;0ACLxCQ7jTY8MrUEm(@CvYEl06YX90gr*dfG5CH;2H27 zcmezkplf72MTwyvTQBZ6In zZS|ft)qwrY0l&^@{BsS-;RQZj7w(D5vA4OSTW4yithaI2Y|&I9G6%iA4LJ`4789?u zlXJmxyP|%~xwSSnURCy!WvrjeoKXt7huX<`e~&3g`-%N%8g|!UOF6Z#n86vgkUPRG zO=C?QA&zAsabBO%$A0XC4bdrMu}QnpziISyg2k14WOwdjW@_y@t1kkgIsb5%t1hzT zsS0b3_%ZJ1`F#`mV;;Zfn8W&P%e?bjLO7Ad9)yiTKi(-hT047=`UiR^fPFAn->>YM z_?fKOM(9}d4sl@IX%wOl@kR0;V!)*Ae@Jqz{gJLsX)eE7abMA zxW8xI+c+~3yU1@ET(LPyv{)>=lkjyGx|2J6_H$wl*b6(M-<)|?zZbfIp6kmywgPtm zT{nNp`&ggYE>6ssvmP%-j7kM`*KF=5i;3-X!tXFcoyvP_v2S0rlyFwD>c2DLH|D@bGU6w4(4F{QY&lv# z?o7U99|&g-KDT9Q-?FFIU=MhU?hHj={)*pU|F=!CBAhaMdS3du#nZ7MZJN|38lI z0?MxH>I3*qa%JAR@6E)KLh&F0g1Zz6!CiwF3Iq-EQKUdAPsZaRxO`ceSDQvX_3GE#`DIyN#_{o{DbU9rWi>AcLoF4k*K?qw{O7I6zsbmenkpHo`(_meICC1tDkF% z89n08J;ioAgDr8r&xpMsV9VexVX^WeIoLD7mbL4JVat-Y>BbTK+nLVwUA8hz8Q;BC zZX!mohWEgg!N;}2#{Rw?yCvpc;mP=x{c>*w+rJNfG!x6u`LntH2VyE@%K2>Hf4H~Z zc83^Mm|eM9zl*>g|6oF z&d2jN+M8cw_2hc?(+WjH{a2oRg!d*7Ytl^(^_N)~us>{u@*(?kxqXRPwFB8_3yKX* zWD73kF8t^o>@D`SfS=2uU%{AN?B`fJ$Bo&KzhvX=NhVG4`d#H*PH{hA&=MFlnBX#jL2K97!=NQFXkz0%e3aDQ_Q|bf zG3PFLT!$;kk`LGvKgzMZ=*;2C#MCSLoA?~Rzm%Q7KD%s`eS#yS%WCA-U@{*cuH%^x z!w)~h(!sihK4)-&XM7fICTFpen7UjJBOP* zYv$iAbQOBpUdBETtD?=&yJ!Qy+X+n;W8dGM{|&kht#7|iLD!&YM{G4Ju{ zo$74eqhw-Q_t_nC`9ZImATFwZiqGr8+mGVwseHLuud9bmSej0FA){aTz>DDDKhkOO z9M_izsmTLRx8F}^>|6g{Oq?sq%?~m-4R-FI#P-DU!f)MCcsYGh@^;-^#N5Ek$;sCv zrX@-9dRbvRA4IN9v`1s|R+vrZz{VwVo*H+l`IFPw*M3Ah>|?wD8<$M*%zV)BB6^s7 zN#OZ6(K9OI)R%Q8@6mT#@efaOj@ROub>yu2*v}u(S*N)Nv#bfGPCl$iCeo!3z<%|) z$4xQ;Hcsxf!uF{pkK4D^$txH)HV;4D-(cJl7&q}YSaxSN4X;I?Ze@GZN7o(hPHO_p z)=wRP~#AmD|*GS>*5x5IX|@*Vx9ZAZ{zus)A;N+dI{ZW?-_Q(8TIbXFVv3mG zbMEc>_WTjHgqWMYGhJZ}pZrjJc^&`rPP%Z2&zRP z=ZfRx?3-gf-x1yqYX@J{o6N8mu*~+XS?=r(-iRO8E7 zDf{ap^t0!l#Qy5z=TEYC-F*C0`Sq~QVLj)Qc&0ldBp7tXp$ zuH;2a9DJZWjEp;Z$h=U)S3U01BzJ0&R82Q~XCfK3IK6x;o8Y)Y%+o&J=}r&u*DLt{ z_x2k;j-N4`FRnM1{l3k8S%XZy%^kTz%;{tNeqlNgdoU%NW@)&NY>s)2t?}ZeX|Ma; z-Nv^5Tbyb^e&~YEQVhP`!{dGWZy|SD9NzjXYR>~K^lZ=EUG6E*0+UWI^e1ADm70i(s-@OHSGjE9}0 zgL1ZIA--Rf8>ZcOwqmyJAKA^(uQ|vU8n-4`A)s z0eJ#z$F{DxbEF@6_=z*QlrYlEOOF|GH+NuZyuJuJ5l@f7$NS>n!XDMghttGq)PAYG zZH4pf$?Ejpb^N#CbTTZw7;&wvh>PEWPcJ5C2Fb6Li=w=X?HMt#-=Rf3(_iR|jlAY_ z_jONkz(H|cd3G`NhM0R@Zl+$oLSF904vF;y@Nx;f9Dkn9prhdB5_q{}CpuO5F}XXFPq3ipP z&mw;_d6M3C4~89zR`Pm2ix1So$F1aqTz@a?dnjwDPiQ4wK4&ldawdOaz`0g@hj?-V zZzo<3k4MMdhp(O{H@+S+9UeG^qsY|H!dBR)RkMO0I+Kn`;Vp{tK%en3{{1r3Q;FV= z*yxE~+ih=-_V>fQev`agpMYL5bai=I5BqqeSm>-|3%1W}>$rdq|1w+gDY~lVzj^Nd z3C?v{Sl)}+pUb!>e`G)Z&AB{7-qBBVv)DXdyVkv2TNjuyXm#&h&-3h(*>A6zgNHsQ zU%rq}R67;M(_QlPdXx2qPw>Vkz7HPGs?>bSQNqKC`BV~kIJTFba|j-e&nBNrZ^Far zgHlc4;q;!VCh&0LLxbWpo;l5v)9k@<_*q|@@t?$CF_ZlMB}-CRf6K!=-x` zxVB`pxW#^W_fKTYj%rFE581jD(8MikX z7v+#9c?*A~p-7D_V;^af@U;3^+&B^%d^M<~2 zDVq`=$FsoU>XFhN_7a!B)``X(=#h9R)bMrwK7)!W^R8~KKxxKA;+bZ1^?tEAxy za$QYTJ2tkods0Ue=*Ii#p6$rJ|9G~`{Twe2b1FH}Z>^Kb)i>#*UwYP9$8j3J^)Gy} zx%|~_#nFBVzpw^w&&j)~V)9X!PPKPc*a$rU$j=UO@CqNl6t@_3_gZ2#9r`8qB>S^J z=vfFey_4Jvcr{pu4mbim1?XmYH8syw_Tg|gOIq=%*aLPvSB`&jzkRXoe1o?(JLY}uz3o%>8S!Vs_hEm?90zTVIt{0%kfg6G}g z&4rhn-Qi?=|_ZL3pA%oItKtv?%}JGdA}b?}$0^WT9TB<>l_~w)XsUvUD%ccPgyNo$lbrY@J`BPIqt?dJ&Bv)3#@W z>4X*bQMaW|2F9xsUaC_pbp-o(WH?sd>p=JLSo?hk-iWndI`V}(eD>Au#dGxgf6-!T zHN5Zr^Tlx&CC4Jh>i70m&zkZU`u0R;_=fZ7CX2R7bFX1b;kQ-!K(KjYqIEg)LXTcC z(IMS1hkSPD_MSWWv%hUd&X9%hKh5xDu9q@>bEfaVmfbWN{SjS6t~@R_un^ra(LSBx z+@{kX&+u(_qPq_i-w13~^#}Tq)zq+c$>Yt4eWm5mJ7VrDs2|eChCUpG^`vwl(NY(-<`!C8uI#jfqCCJGVfpZHug#TGkx)2GO>pKB<3~FeTS)& zW6$K!i?FTd?ZzWVIG-D>HP&FnUJfJ4sI&3=fqK?FY#*=2Uk{NrpV%ioj>I=wVRPTN zCp+YLpZz9zwHkS{bQ-Ib)M1Hdu4^qXM?052^N9Vt08V3+bBS@f6X=p-i$NIqw0w^J z^fHY9hTgXr8FL6-w>8}1>*U={{Ea8=$JJ!w*6u0XUb2QeJ34PBJ3G_p8@z(Xku58r z=_n^p-{Y6`kuB%J%Ix5bS9VtK%Y)W@{-71kw%=`Gp5i`I00Cg5+xD+pcL9gsPw2Q8o z?i_RXNFOu&1P>^7-!F$T14b-rZ*eu}vbVE-glt)iY}p;n{|My7wg!JuH&oG3KwuSrlp}p#IE+5&ugZT_6``dJMsB^gA8UF|E=-nT4c7I${X|k zc0Kb0_U^Qpmcr;V2J^Ccuz*XJPo?L-Xst2((Rn%jZ>iK85Q$_hwI#@1ajosF` zp*6wFBUHr_OLsQaGzn>lYe>kA@0>kXL|^nNUdu45Bq2{XWs8`uzhOHVDE;_ zYU3|p`{0E8%6`uW$4BN4*VAl<9t!Gj@zbYx@l9*_1=15mtg(}=I}^UNNsly>`_fE& z8D3Y8_(Ht-ygNJSzQSA34f;5-o7B7O_t%Jhk;#ob@cY9D=*O&AKay7YXZsD)C$`%y zpI_Ifq%Nn~VCS_$m)P%R{(htN9YRljOy;gchL6Sro0AR8^3^_c4sgW$g22`;^`Y*M zxY!alx$H^H@;<+tI!vsZ+&CLA59hD%PseYH_C%-ZFHyJ;3&NT=Wv<4u>SE{nMU!r^ z!89S$+A#!pFutyOEdn~CmnWZ^sW*cW&h-o>x8M%MfGXh+?$t==H-gXjPp|(TT|xH8KJ}}+pF5({ z&`>_>-|*fB-m`BVO{oE8w~3;jp*! zx3AgnTaw>_+*sf5-yJ%Qu4<^?o0&Z5v_9k4MR^88s0U(40z;@4l+S4`FoX#VA^8f2 zZcQ+R?9ag@_WLriK>rgx|LMJ>>GX_FUy)w@!20ze*H0vaqt$nYueMb>mY+B`EJ6Ol zT9+I7PW5nY{FpkpL>(Odohc?PzC~Wu=!UUqi$V>ncJrz#6In98Bb?e7D*H-+2^z zFD2Wvo+vNF)xPg+d~>38oQlrk`_6Di7o*$JUFbO!F$EDLvpU)sZGyHy1L$IO8M<9; zO^g-qb=mW-EjRGIOBStUW>LZmjEwR4uzQpN z&T}{Scp>-rCOr1Nvp7-R&MEf3N?v@(@4w66j!;i?t9}1p)OTq;_LfjrEN_Y6A)UQi zAvD>(=@A42rsuQ0>$dhOY{hTL|Kpv}AU$}Y9PWPj=2`djSTaJdaJ5iH`5*SjX=#O@ zE*{4A7)Jk1CNFx?x$3unPo7R9tHUrcXlwhLo_@&Mf5E1i>kQy46ZpymzLE^C@PWw^ zuiImoUg`J+hEmT&^}gifRb<=R{BJo(eHaQpNrxVYmGT}o&d%uRp)>U6(uatD@t)XK zhdTpriMuKZyk!z`P4Jd-$)q4@^$Ro}>0PL=u)2Ew^F8k6N=d7%i{0*L4I}YGB^|}% zm_`2K#ngNNaRdFFVH3O61J=}Nc7=o3cW1H_Hh1slJ2$n8V%~jvE2M24%~AIF8gwmP z_^99iL|(7M|CwfWvFGOAQGR>QwTf&S!>Ok&w_HP#b;T(U9 zbsQ&qeUCF8KtuD2c?SJ@N%e+t*8U55@|DQ6oB0N@XX;L#Lmd-+2+PVBx{Y1*41M!E zvj22@H-fBR9lc8bY{+IA?^z#l-YY;Y z>;acHgH3l;CZFWo-gK_p@@1|jGhQI0p1`+Dl8q}n|JC^kYw!=?%jDl?!V;>R_nEJe zA+fK!{>yun582 zgjwp6^N4R2&q@>cJ~>I4Y5e*upQ@1-Z_m8vLcJ=_hzTvQ2MJya~&f z!1BRtR`85^7`g?PPflI$FLDKzkAxXc$Bjs0zofZ7_ek=%H*1D}(#8AW1F=(hwY1cK zDq>>vo2iMn46+O5y2+p^&b-gF&G1vsh<{S(W2V+2FJYdm^2AlPx4Kb&^&!>P`>^ai%U!(`(G_Q1k)^ZU*WhR_|))Wxb_wy$u6 zbW)|={{xOtj7tARKH9IX=eI>qIF&86zwa86xd&w8#cZIB=tunn%0=uiETKq5tg6&& zgpApljJebI%(V|aSrw*agnY+5{!gQwzcmA<-4AdTSSEE|?RpD+rpt!-|8buA5B$Z$ zt?f|q??Z9>1AJz;XS)b)b7k>?%;#K8zLE1zI)%q7VIXSqAT|E;Am6`R47??tq4#Fm zU4HMquUS*fA;Vy?zt|c+69!9e-)wHS@MSS*p5INeBAOn^58=9ph^aeFT||G!T#&M@58Sx=%d&p;cNE+#wvN-GyK|qO)0A7 zlGd`LyL_8_y0zcKS+O$%{1(9x@^*rxK zY{@^$aa=}DzR8~ZJ70EddVD88SLN$1j)xlPb-vo>z6UO=oil*TO5n20CJ6~#R{Ng8 zWwmjWG3H6u==(Dux0yx&OZsGcD=# z6MWZ_o)c!PUH<{I1)sD4dwBu)-Fa?TLu|87ZujyTy47342a|PMxntWqllA%EOV~TH zWO4LPJ^w_C?aPR)yPWHFy~DaaR}-%^lgl!_in3lf(iDC&YuCBMSvli6>_vy(R)K!& zJH8w+LFWQE043bTGlXML2jkU#EjwK+*!COy%Efg zU?;;(xwnCT(WlRKx1M&HUP5|RvCaF~gIkiPJdN^BGJiF`Y|OR%hW#=t&4St=c4Sua zQPjoIC3uG2mcTjb!(t|gpJUll1v?R@Nw2(`+(f5-dHMw)cqX$0x|~ZFOv`XS^Q>eF zKChsd_gT|(KFvKjNvviASpAvyHuecgie@rDYn9it+m3NQ-|&TYAl*hdSAR?nV-rLS z(k1xlP4=z&+H#v5rb?V>MRfu-@n^Y<pKPC+)c(WZhbqD z^Vg&I*aD}^TaWgAHx)sgQ!gz47ON^BVnc~-mg}MGP{gBNhyEgdvXsvw>&oNU93}g1 z1iNE`c*(Nt=wtBvi}?NeyjSmb{)l+fc6eiD`~@?VzziiYL&@jzYA`|VnG#+2rH?FJ z#xq{aFZjyy!U#EMF$?@W#N8IB;EPp~BVa&&O$L47e12!oUm7~kJvQ-7WS-x_YDi%0Rr4s#}Jc($SRA3HmoiXtZX0?|aQ>oo&tUIpgQ7QSan%i1nG{sHUb9zM|8e8sYwrBs)g(YestgD8C;~ zSC1ykN5cb;7Oxo-%yCp>Jk~yq)uVZ?cx);r*b1-su1U`EYO#WsXrV`GG4Vlt;)~?= zOwQN&EdpN?_2oaUrV z$Y43>qb>LphuO2WRaJ+ZWSNZ10>>hliiE{ zh<`0lb@$)4-zWS0kJ+Ge$bo;+gE?Jtyz>$-D_=sh`I3J{Rp+%6njwz3wKJQ+c7Kem zwlJN)ikvjuv%7A0=yW(DK3tP+rq7Ob!4M@dM6ih+>bqm5OjYbyod(*P?w^g$rypR6 z_(LOTiJ5KO`}=hJ=Wshm;Yo8F%|@ASj!uzWTD0&^Do>Hc92(qD2fs|rl}x^fyj|UW zxrt1>(_L1>Uw(oQcg!lW7ZOZr*2WEPPL4igeS>873-kqCQM-3DTu}m7l(2Qw2A6V7 zeXyR5QZJSA|9sys@cdiu-hpJyE95AfubpRI2p)cIys!;EGk?)tFWR=?BmDS=v#+}^ za!{~sW>Gqq(f+_&D?wjcY^O|hrziq198l$`JT*7N))k)c!Z@?Gq2xFK^`dg3fmbv@$J^yZDe z_g(8+ldZoV`SOD2Ft-u^%?MlCUpOMMs(SJi`NX~qZ_=%LjE0}ZY0Yl*j6I=6SFA}! z$6S-yjqM(7J=XUz8|yrBa2Qzz*P~akJUO`s*8^t*e~6!8dJ>qP*c%J}7XE=B7h{Jo zJ$izepE_g|pCvEPvL{~^z3^`^J9u+PzQyH5F2~s4J|lhD#JpN%Ez=WYXpdOn95!OA zZcXj2J<;C=pEr|_-1q6;AM5Q-qEpT#n}6o_(v$q^z}G4D^`xtrZ%exuw;H(j5KWeli!us>pOi`v_(z7qEcdZu8d(;as(}&YcG4~EW501AI%zIP|(5GIr*M2t1bn!>`=r8Wh zl4Ru$?6%YGLk~Y{61fO>rsqSI4_y<}*S8CQALN`CP4(|1s}Dohc>SjKZ!Ej1&Sn^} zujBbXW<19EZ(@@Tb6mx&(@cH8e*W@cups4Cux8hhiGzAQGI5d$T2;82nU3cVpc z$H{1XYOYb5stIbUDKg`NowTX@qn3Gx}4|oyrB>FnaLNgroxi#y= zxtrlA2UrbeIO-uf!a2>1wYABSzJF;k(O7F7YrFSPTQG6C{tWh*Z2!vLGS5*CO+K9c zV1{GZGVM3ZvlV-B@nst3u%zYR@Z)*WZt*&^9fR49FtrsuhRXo+&jzTuGoA8RGvJ0& z^*)UxmA_ft{vR$D0hgubG!?(d?R8%M=-C!`=5M&`o6|Mt;FmwRE2nwS3-rXoWawzV z1>9EhC3|vDh|Z&5-DOyjNy9~!3;=qX*%plhq$2G zgUAd>wqb`_A6QC!YzAbw%-O!|%x-hObM2)WknU0$%z$L~!CCp;>F5z;2BaASRk_Wo zx~{6e2UYdYRk3r}a(Bh-N3o3>JZz^Ks-5IiXBdObeZ(JKc&SVO{t?04M}0u*=3mH1 zrK$65hBxzu+8wq58D-{U7>-Z6{OwKr_3xqqkFF-8=!=+s@rb-UFK@N`otQ}!^MSBn za-4Ycc6+*5(I?I=W|sMF-jpk>%inZ}1E`O6e&-jh@B-gCqnGaR|7IqJ;b}ctg?~2$ z-Dt9Qj8@7Oc8b}%OqMy#}t^6&P+oWx*GqW)Vowcj;n}?1;H^ci^GEA67t!|w_^%*$5a`A-;tu6<=m7LRG9OW$V;Rgx3@`aEa|iSV ztFqDi^=faHkMUPx&sF%eVBA=We+bG3+2@V{+rcoon|4zhvaIb3o&)|*$s_I>4njVN ztpF=VFL#J@R>U<#HsNh9aG$pJx}V(Bo$;<2h2pjW4!bXGia)mCBmSFQkM-U$=W&@k z@`*blw<$NKw~+S^N3dZD|I|E6x`15(8)lY6P^)1kftbdl?h$Ml8&p3~{^Ss^g9}UG z!r)uXz(H_fY6|;e{h^*iFs8oe-J;G1O7%_E^O~N4{YqfJ#3w88cxJ3R3)ruAjW_I< zTpxTEI|%;EOoXbKLyZMH2uD(vk5)rS2fSgg$Frg8&KSmv?=Mc`GvT)Q^xfi2(Q&gOyDv!WuHQ5Zgu^IG0>N1Vqv z_RdOpIF*x;hbfm4AJBK&Hx>yTR&pkS!&0;7PI!JetYn)sOEz}T#H;lPQ3p)-nSre) zQSUsu>3n;hiy_w7*|CSqJM=bC3$D){KV?le;0f%pFYxHQXr;V^uTzn$tjMKQ%Inzqv0tCs z5WPK1Hdjp_mKvOD%?y{3a1FEdiAfW-wpg@$GaYfD=Y;!`(jbMJEyg`#p)OUtIwJW*4ig@Cu?ih?#0-u$@XSFf=uvu^~CEe1`7S~50 z>riu6F-uV{&idZA4|}r_?svaN@z-AC162L(2R6+~*1N2F-81NySfAJJKE7fP?-px_ zxWL`rjnBy`GY;8h4YNbic5LtjYlYQ6jPw7Z zuLYBZAF6HL0+Zzo%^#6x=)>z*dA?13cbpON0=&xVzSoRHJ&W1m^1=G@$}#oB%c?2C zcME2{?fK20+EaKe@xu5G?v=X%j|JmfhoS8zPdoTq9el8!a(8ENxV?N&jo0d4yNZ2$ zHPxTQdpgLr7u}!L?d9LlMgIR^_H+h0w=iDL_t6A2HqfhSlMk zU=4g`%V%Ck-kjl_^)=!bbik<8;F(5<3ukN{au)yS%PGzS&q+r|-0yODSH4GVvhqSyEB_^%)CMOL*--up?`5oro#CbaU$C_~>hDdg9M6R2+sDD@$R=cX#UscVh zm6q6_3=@F4sa z`96TJ2kBk$OFXtk*3kRTEEliUOIW?Q9uxTU63=m|*z72>a!>c?{=A1RSl7oe)e9#} z9W=pb|)s*4frW)&5* zgb2w(Xc4ri{Zk3-)5eG`j`i0RKB)-iG`b%ZHclVCpg<(;HDd+df?fKmz1W6dS#f4( z+oK2keo22{n5|%5V=%9g9hvhV_5E-U;mMp)MxVebr0`yT2T$hq*TgwvN0|}wnj_)n zMv@65^DPaB!}U|ceaUHu8ZQ=*%Y%?L*z?r)IOb)q_ zqv3O)gZSbR=Q`2%$!yAvRl_KDwz-gM%k-RZ9}e{V?|N;t_ZLBCJ_a)%^+Xk8VIP?J z2*Xu{aqE{?(@z~QtMv%ak{u)RhFK#`c$IpHGa%oEH`p2fo(((pduuUYQH@s9e5ktF zCOMrgcZ?TqXSXludm|=vU-$WXa`ggnn8^1qLt-!)+=jVv?sohSR;Zmrh81#l(|oqv zIDKwU)Pv|jY2RKTr>1!J%y;aPnxllaCO_Apf387Ci{U@(etzQ|_w`c^wiy88kLZFJ zi{~${D*kpmS$MnuKi>a8C(ZzeEnm|}*7l5MDz^I?z!aGUEI;h7!4$zqvzv#GNcgYn zOyF?D=)bmh*rG%~_5@}qQA5Rtt&%-8amjxDk9{uwzs+<1*ZJ4!vxUgu^~j4Woq@TF z>PXFBFU;sk`^<|<`CxJ!$gIUMA3vG37;_=y7%aT=*_Ca$k$blhnYo7h^$=ZhdkS$$ z4m}_y)=XRKFS^AT^yn539_OCwM=j1fP_96plYPNV#9$^OEMgs>W^hw-JXt6C-KCGx zEWUO(8P|kM%Jfm`7Ec+Z>G{5ezHs8|r5=Q8SlWG6ckzx}s9tw-k#so7Xo++|h>i?d+m1 z*O-;>vq>g8?}ONLBb@Q8_HtSG@vpwytiW~-$*e&AF=nX!>W%qo`1?U~0Xl-2f&8&P zxR-izH97GGx$t<=Vqf>FHBvW`%I&h*&HWRjfZ4QWbN|HF%)hlyH#rlt`NI3|dbE|z z=7R;Vv}gO8&8NoFJ@nITzA)Zdna!t9Le1>0ni$ex&_mBXZ0UEYSB2+?OA_~;rKT^H zUu(bzHIpZt<4;+myw3kW0NWPp(64oNvHoOZ&$|GMGio;#6G+LaKcj`n#Q&iy@bdv= z)*sMU^sz|?;%R0MqQ}+Miaf|?XYAc7+{|1#F!nk<1E0-b9bl{K&+k62QFPa9 z&F}i?($$9Y%klFJ`xg6ai8IE$zcVP{;Pm|=v+i;CP88q!$h}+K`pg5-FQx{|-06Lt za8J|pc%0!qIUk{6{$EkvE3TZ-t=DY^1-96a$>4MnMz$DD!reBw`Lypt!#ksq)?{My0Tm!$0%pG+>T$zOvD5;x90ZO$H4C*WSg1toAn z30#o8e-&P|$_7+F$6h}K-|J;0PJ>73jAQUS?2me*5{{#)mv5C{T!XKuwP!n-*C!SS z+wI)V>oYsfEM&gLN-$YGcm0HmINe-w}JZzeLls<0sj^TO{Q=&$onH-hQ z(2rP84Sx3b*1DCuJu+n@!dATvqw*vFaxwd@p4)7Zj&etLY)L$@ruY2QzLoa;DtmRF zJ@2&V-R|?2bmIs*EXL2hKlyLbFvF1j=kD!*c6I+^jltz)%`)!s>BzjlVBTN&*nR%N z-7)7+Y_lSNP?6iMz@6)%jkYJ3rl800(AxOloWJlP+SWZV=T8hIn57levG})r8Eu{B z{OM^9BV^B3K)WMz{>(8g)y9=(pp`*iExEcX{bpt=GUtyCSF_JGwK_HR(lxTMQw@8U zJKZHVH5}e(B)**;rigyP`Ipb|lhkLGqwLc>^8PR6!3Owv4fhXLN`1ZgQRMeodaA~H z`ryu;iZ5WK;6p~p-OR%kb#-q=vX5MgztP(rTb66_hgT`e!*P7(7_)3l73y3ul7HD zalL0S2NRFz6F}~5M#r6}M&=o3{h)J>n6~?zwalQtT6$Vo|7XtjoV2CKUn_Z0tPEBP z?+)Be!pMsI?Gh4Z? z4@ocGRVORE)htdIFG=ZA^$%jA&w9UFOSz72eP_+yD&UJe7fezDla#@a*C`$crpb1(XgxngGX>8IGA z50;3YGE?6B4#884To$up9ZO>%j0|2{|TZ+jfOf<1T@{%nf14fi?y z_7R>(y-eQjdwHz5m3s-R)2SA2I6fZ{<2mJ{csq;8L(J2*lu`Ka(H{b z-BNsr#qG47m3l+W^KLyttuxj zneQpS#qK|vHk6MGX3B-H?DGnFs`sCM0?vKyqCa^OkL+xZXFL1D@Y6PU=^CGOJ35AK z_6GV6EsGacLfz<2bU%6##a_<~yH}4`=S!%xmQm<2v@D*CwSvDv^40RkYB|v@=nnKC zdV&pchjsrIeT8y7asW~nDXv-S&@Op2O^4aw}MBkzx(HOdF z2edQV4IPC}Mt=~uS)cCO0L_SYD*6s>NcVbFvK)%|vF-V} zW8Jyq#ZfOIzb27e;ymip2l-rl40m=la$u|-`W4w1d&9q-_NfEwmEUib-xVp}W{`bv z7Mi;}E^j8UWGQTi+CjF-WqBW5fJrOt=BLPnb=}QP$PqPv$>g+0-B$74YYgy|{ zQ?ehR?%ZNhZib>xrlQ9dU?~i z<|4{Ns1smEn29JpCjTr4atxbc5B7qYi2AGLZ9nsHa^nbcBl?+-)44CQqrP@VH)VD8 z7kR9QmMiXHBkCLCGe2ivm|MtRN%<3LkozmeTI9isQmjQUiwc~7kXse!BOk?D#J|Lh z>0hxHeNAd=ZEK}ii`aChz80Nu(`JwBrt2Xed9(inpwXExUG|uciTGhM?v&qtKHW7R%eSMB|f{Sxsim-2r-}t`paC(rz z1CX=uaAb&_5rT(f7d6zSnc=E`g3>=@% z94+@82F`sHU-W##e8zTcjB_%+kMCP5t>GEE4Xq&dsp=ReS+6}YP%{#P`G_#I9r{6Z zz;o%J$B#50F?^L~_Bq$P$9Xw3bAi+Wm@UJmnIxuI4DCtQ!FM;Ydv5XkdpZ9p;P5-!MCKs|^APoQmrFxtA_g-N)fmi#wa_b=eej8UvQeJtr<9vjqmCFaTt%ZtNbVJHs*8uUU_tuyy-vmCGPTNa3S%LrVa}sx9hJdlN4-fuTp$JpyC$F0G|SH{ zkfN!UyeR)FE;V2L>J0wZ_4I!133XOB%KV*7e`kG^eE&!K%v>u+vLE{|Vin9ql*dcO zW$~~(9I;D#`>ZGM!)#6f3os#>WQY<>qYF#*f4m$j$x zZ7?R&+!V9Qvq8Qv*(FXI^9XQm>J5ry1^K>jtf>bkZC|`T2S0wol-^BT1SXL^Ia&;~ zkR$99-^|RWZt2}T(>~gBw$r8dQ7=k%uwI2^@AC4;lkugwjBqb{R2MaNe62i~z4V3s zhfjy8?$G;ET`?PNG{@g3;)#EVJ6InlcJZ(N>c!?bfBiFV$VC2{(>MNZKjGXy- z@)ph}>PmRy@)+Me9KA*seLAGa%#N12)^4@ebzIX3W<2t93$YxvUVMphX|5KR?DcGB zWtt7EPa}CX*}2Sx2|V1ImSIO-Fsw&Uveda}@+tI^HT_e(?LlV?_r`|eFQ>U2OU^bc z)EWeHQiJ?oUzo?A`OJP^LT^1}%|{O#-p*|==ncql8>)qxKo873^ zx)R3YRkItzH)MJ2n;<_V2VNCp?hm8z)q^l*hqF0XwXd;P?(6t$TXD=DcjN;7W}f$a z=d$a?!`SH=`&n$p*|=ML!fx_C)xV{i4rnFs%7dIvZkX-JR~Fai$1Ifhm}#2Q0hzo= z7R*@;aB305f`4$6@0`dkcrBIpCV$OX)Z3`aPp#?oUkhd|s$)&bGFTe%=GX&j3wrWs z=X8*@U0aBUi){>ZPcvt*0N?6kzS@!Q&>HmSYQEuTe6@~Veq-!Ctex4YaHwLWaCQlt z9c)oeZ?Dnpn?|{d=UCV|nByp>oAEtix9}5uUF=z*7NBm1W`hmXrw3j?|1noL+Dg{U zQ~lJ6ayNJHN_y-C({D(c?(LP)zUwLWnl*yR`(pK^W{@j%y;BR&4Bkc`_TED*BzeB#3;zu zqv^|Yoa^%R-Y9GQnO@MXF>FZh#Mz}VbLtrC`nae;wg=C+;fK;MaC0!b-D)+OY*ev* zc3aHZzV7aw#4k}tFP4_6XUX-PDP!E69?0pVLJhn=sqBi2+^3i?+8htW+GO)2gL#th zy)bm@sx~LnPi6N_z<+an)&$ri^C#rJTl_>bpUKes$hYm$crt7acmGg5zV>JD#60j# zQt?%}|kx?u8ZZ5#Mg|L-d8G*J1MDohxPmhj!f*OkM($#}4mIVDebhUGDS|W>KUGY@I%) z<|x{e&G6o<;(qOZJ<5u64r8 z@gvn&6y0JT^0nT37=oAM8<^cmmeuLc)$q!hc-H((HOo0%SJAGE)Nk6kW^y!e==k8T ze!m-=do-B{Q)jkoCch@fOpa{jCp;b7rfCk0S|;}MDfq-agU2$4wW(GpP=M$Kb;&)>GdLpOJ7$%Qh@)WP(OLuW>+Dx9xn(Ef;VjrFS%h_#tccjnW zSl-BdOEq1+;T5mF!p*Idp9Q{#iE~c9@=7^9KOO#~$tTe7&-=cVSFhs1JF^r9F&9NL zvz;!w&bh(7!Dhk6IP>Ta!@MOgcy_Zb^++?noox6hjVOU4m~9!%wrtz*W?Pc$HU2@3 z?4Jckr9RRgZQyLau}_CMpR>|_v1Bu<_%M$+mpIFFEIGM}XJ5rx9w9EZCqDR^p17NC zI*5)kqcWIL86GD4R8z_Y=1cPx1n zYyQ`y_s(_~?ss;76EB@e@5Y?_zdb{oM|i*Q{T#uFu`fabBPOp`<7=2*fMCSfNoEAI zAI|gdp*}O(kY~_Ub@%8#x+=~PJ;HM@g^pmm#9DhZi_Hk2Gx5_@I_gZ{`5irdcvh6J zu#tB1o=iM8_P&a<$A9VG|JiHIhzxou2Qwn&K;cvDxtWjZiS&-J26$96PfPJ*c8D0g zxsUw$*%6B`$H50id*h|0onf49HG~|FSYCBEWuQ|hINWY9OIp)xK7o(`EMH-)SrPDHkVm2C!pfn;H%G^$Ggm zTm1TGdD@$;d!JN}JY%<7@5A;7{#XvL1J1T5{GEO6`^;CI3s+Qxi!*V1>oY4doWmD0 zD>9fB$sg~B>#8Rkvgg0R$7VyS0m|VIbFpXk4u1MO{jr^WyNN!Gb-T`n?CD5g#MD#v z!@-&TPL|Eh%(pCLx!kYQeTF=!_(;XN*#$m-5wsZ6^Do&9ZI0p$x0{D`!76nnAKJ$| z(4Wx*=mqp43w%|d|BmO4w#2zvD@=ATzAxx)>wpzYV8s&g5`10}Yg4CYKfCQ6teC!( zFcxfcSg{0F%&eT*WOTEfLx%B9`7Q%uRD)h^ZmPX~+n(+#SG+y_V_s!=D(@+`us_Sv z(=D<{F0;m{|&x_ zt&pdwh&Rb^+bvkKm`jG?YL$-`t?)&fhUxaij7$D@E4d1P#@X$2oPWfKJw)H!&R+XV z^nr$q6{{R;Un_iq3ZAaC<1knG&iSaKCSth#nZ##dZ|j$;o{e1I-S<7{9OjV62hnA_ zWo8gq`%~=l*X+}$?jsDC7;v*a!vK~miTGGpu6FG{ESEW}Rk7k~J01$l1#6kLWA2NR zk571S?9mbXu&>LOIM{cs$(EWzmTiEicEPi=@Dpqnd=I_ndCiQ}zm1LOZkZXWE+Nw^ zs2iR-rQhKatoa>sb$_-?552Jpn(g)GK8DA|!OVTsUnIcDmciUdxQ{A~dQBgm0lEK% zm})C|M~vbMyfVRi&3z2958@u4@x{Dp-bgCfr`In(@-zDdbEOWaQ9erd9-5njNnc#z ze!gm-j&b*wECE>+vlKknA&t7T3$jJ=AOPWOL9JYpuKy54U7iM$V) zS*NFK>=Bro1SU%yn@n(K@L27BD6l6H*AvWo48OKtW3-*iB}q&w*UlkA-iclU-TM~YKMTSa}R*ljcR)iTFa{k(lX zgAa7CzcsU#y0&_I#sHj@xd6HE(9cjlUH<`jVKtrfGTfAzY2-88$qdKvJbzvMjh_J5 z;yzsxd6RtBGeX=0uG0R$?spN7@eKR#OR{4F^#Cz01+zr9$*Z|LFiS9sH8G|JA0~*+ zi!ibu_?P8h*{7Fh-OeHnPmDde|8Lz+C=7CZ^WQ7lD(o{)piF3qy zSvvKM?P9M?YsaIe_*}RpeXh(CmBXI9Op9&y^(c<$DFZQi2NP6d9idoWMRG38Cb^+)^LS8I~-^#MzTW+Cx^nB}&wGAemI)gcfWac!ukhGmcc*x$EVMzA|J^n-6o`T5?W*EW&ciQi1KBJ-MbgjIE%sLb1 zt_!bi@2;%CfBnLKnM0_TX)l}%zncDveOk^VH~)oCo+e8V_Z<7UmwI=@QK`-Jnwa0; z5TE^zUv>@Ibp`%>%x4{f%pHVh=#xXv%mFjYBhv%iXFq1o;F@^cfsBxwbT^0cQ-<36 zm50uS@77-*4@Q}@hxNT924r4EvU8?pmnt1;UysGtBkk!Pe1{#~{oT+T=-s?K&ZyIO zsRzDZd?#zTlPz^(t@0Le&4{7imu>i(z1`bAg5%?ZXZ(#OUo%yAlZl&UL7k$yojjNe z2)|b9m0N`?hjX&`<^rng9?n)BDgHOAP38iM=g-k^p1te&=Fzc#_g&F8=_I=jM6q`3 zCG;kGhum5bU5e(jwf4fzk0Z5>@L_t+pl^{{KfUftxTLb}SHxZpH=!NKw2RQCXg>Wt zolKl)A7Q!lx2wu$%AulR?vOfl{UfT$apG*7lAC9ttB}~gm|BfbQZu8X)}B-Hl%KER z)Aebl4NxDNhhlxzfhgv&7s0p^;U9EF~a-wYR=RQxXUp&IhhUB zC$UbC>lT ze|9hQYnMmrfgP;tgO|eW>ErA5o4H486mSLXr)|YQ4|AW7bvIYB)>A#(7g49Dw668V z-aHH2gAwRvr?4bnB}PZzCP(62x%b_5*e`Pe;Y^*s+>AYtU$ciWU+tVa%oo1vN?^Wx z&U8N;_N>WHXz=6B^R{PZ*U`(p;T*C#<{NLIgKxl>&)|&M&l+AzKSa2Da%TfPv5tFg zzMXqLP5w>%J#VP(uIovpuawu_Zx8PC+JBOR7qhA1rQjaB^}y?phv+h+V>&;_3@`G3 zkbm$AoADmD<0N)stY0}9O@iT`K;JB9jpF@bYoB2@p7?CPdr>6+Z)XycFC(g}=wn8q$ZS#q8aU z+uehw$j^V!e!N6|ek%T7ulixVd}+8a?{DV%!|E|1$|xt%nT&S_$KbCqzUxBr|8k#q zzjd5rkIl7{|JIiopPS1R4rAMYk4Me!9lRiM#Oh zk!(u2=A_$x-i;p@inrDdd!F%X|$HXh{bJyv2SW7d@{B687uV_7g@O%%t zM;ll}tUDU*XY6sQe=@vZ&_h4OT7wd{NZ*K3{|z`$bS?WY6BGKtIxcq4E@Rt_W792< zo}-`5h!Y=k=41%`m^^=q-x|sGKI3uE(M3+(WbK>gL7y;lVZAQutF6d`7wqxs_V@#L zbT9V4`EhzISO-~Zew-czr5s*WpMa`fa5ZvZP~S>ar`Z{ z=y@y5lB-(MUEVemk72)WVIQjOn(x>&u|_qda@0_qM{sv{kMM%YK!8c!Fe8vz4gX(zme&>kKDN zPpH>och7cb%uUZaPCoo99Lr&lKMqC~YlDgf_1O^Efv7rx9p7a!EVig(8T&4$O z#rf&KOYU5W9}?%&;VvC%@6Dg%$JFH22GkxmlV!#6&%}ez;;om^5~+TzX+^H0)cdU; zUQ`b?*c^BzyVWfZlIh*lBeq_IiFA~ib3s%!H1XkJn!-F6av~LeTTMTW+3i{(bLZp| ztH^jdy z(|O0(zj6H6ZHrtV@1{PndZqgQW5q=tMz>~iDS6SZ(;gtxc1kyr1Qnw;|gy zGVLX@=REiEEjnq6d$_we+emkE8{dC~{Wez)#-Ueld;Wm_lQUR3OS0ouV*y8O`L^!U z0bbC4S4UGQ|#{+eu0$SX3svxfvk6sU_`w3s9hfhRM73Mg~ts(fL1ipyv*3b87v46ZCuk6JpG7liR2EV`xnYj_f z2>X3j6Ml~k;oQ{xl=JEGW9`wG&Uh=Ob(g^0E(05I5Lq;GNRN5$Fk$v=zMSK5@^hB+ zeTgkzabMtw*yAO<@oaupvmN_fif?eA`v&`y!2XDVnlEgfus`bB13YT0yizRfT6W4% z?}t(MY``c`LSe^uy$8NF#5G;>gK&6?7gYDdU%sam9Ge+UH==0k{wX1!6`v$vC zKL+*$yiU89wzyTYEmxq1u#>8R{X-AyAz+p9y@8&Ir389<|!N-+`a$yb+^oY zqdU}ArG3f4@Hq*5P6D5!_mKH5?#sbqmrI~^ z&>!&pQ+R7p^ga9YemwROzCXvhmc#eGbYeIA6TXzKI-Go(4WCz0=K(X%j?hO`Z)UYH zp8MlMA7g8P$w^>x5||uu`5qX!MtLh4W`-Nx3m=EK|G)>@%KKn(;Cm`&Q3g3VeNycy z98Pk0tPS>D=VfW^Z=-%v-Ikvd#ea|IQ|;@V*#qG{XJv*5zV9=)YBv08j~He%nUVF7 zAt@U`{Tm*dAO>?KIdqzs>ehaD1wHu>IliUo)HwI|LHxO`_4LpIur=}^vy$bV*Ynl~ zOCuK1A8~{*v8j1=E%Rik?u3Y zEtugJ%y0`k6+PhuuX|B^V~Tqh=XjZ^t`BonOaZ>f-k(k8EQi*&?<>PeE(9CWiFA+g z?@@YPjTVO*4J$I5oi&E+8RPeJ;UCIiUYk0aX1iAt>`elDgBS5+Q6#W8?OXut4L+&x znX1W=@QeGp7rT%*ORxi9vM(iD!jOO91 zjqK^cnR+KVg!{S`$TuM!*D+_Mehm;2DZ zxtWNb?JRQpE_UW4?##mSP|taP#LbPyv!m(C?ekW6-MxjAf$QXZu-C7F0b3OxoRCka z13K8Wfjv0@ztb|qds*|&_O@sMwdY-_;_}u&G zvnRa=?!|o!WO1Jw9yJmC>{dGajQ;!+=jc; zv*V1)b`SQ2#3f>E!Ynzsmx?@xzPrdQx$rzPOOBliJK#R`u{+I@(=Vi|CudFXxj{8v zt+GFFmH#bT$@yX|a3=}e3EnC7T&P;(0Q|7NVp*qJ-7fKjE|`-}{nESmBh%Q)W?-=w z|3P0YPnTZijNcUd{g?F}l$you84j`Tcf=~z<^RZmnB7RwkZs#~%|F?P?EY{%Ir3(q z#yIbV?aE{Ab9q8455jJ3urKbXv%e&NZ@`ydv+Li@`^&ZP<(WRyd^tTQi(tMSEG?X` z=QCd}M47u4eoMts_hVy@B}2y3&BxI>GssK0AhACFp=UnC8J%UliCW>py536F+mnU& zu*WvBw_-Q!^8tD~$X)kYyZ*r5_kUSa4lX0R^ztH$7pM1+a96MA>x|*Y?~T^8j&AfR zs*yKqdA_M=rn~u&`?$Vm{RDq)M(!M0RN&7l_(}|&F8c}Jzru&ndy;=VTn~j2?7Z19 zaCD=!kF*ETR)IN*H8|y_=x_X~v(*9UXC{x*35zugR;E;!sE!RqyEXQ+)WsJTty90J zPQA^#)RfPJpD}Y~SWg>oYSx^dZyowubikvCN3eO#of8iZ@DD+qaw(psca=5171xTk zlWRH7=f6hx@}0=mLHUuY8enrN$QXDRSWo@=+yi(QbxLFdUWa!{;9Zgl_GLD^;z9dz zuzl$#tJd=UuiKNi(ZQZiAEojhKmX1bpUqx{!!SQ54Y~Z{RCjI${dS%;oh7z+JpH*N zxw#_wYUW(npZuT7#u|xVW}v^Yea)SdYc+Gp{h7pu(RVyNfrlsQg6=p!+` z)zJ262edER4^2Twprg<+=vZ_DYN0p-{6ch{c*5=O;os5EbjQ8uS@gUZgV-8*#?GMI zs$RP@yLf4K@fYMCJWm48qd$_F-u`_)Ju=nZfuoUE(d!@$ZM=NL9Wp=8%+8wp3I7vc z9O~SFgiI*Ev7^L`r=N=&4SKzpG> z&0-_VzaP z7Wx={FNXIg{_Yy~0ahsD_TU)Az&ux+O#>^`#xcSQsWUa(kw5U9nA`h!=VLnVKzs=& zl)wokqqA0dk-av*PE50|maa#>HB}Rx%3rcs#MsTSQ%l?`htP9zZtTzOnxp(378v$Q zPok`lzoO6iG=W|HFYB7XMwyqhm-ro9;Mc9#na9#Q53*OjDZ0(Cc!;ZbTad~%w!-_~8{?i!WGy{Do1xeL z$JcGfUV+Cko3ewx?vvYUswZpmdGpY4kIalSudWvsH8Y#0Q9kMSzCD;3XP>&&jWpVR z&;IxW)&_=0e>&@ewMk%Yl2``>Yr~!~zltq1&fSHpNggfga1<>zo!%Shc<29bXBBDS!!0dn?>-&cN}k}4=;L9| zWETElt>(J5`vyGCcGwG<>lVy)(>pYHzS8WBLG#q=|m$3%iMMi(P!>TVE>pK9=d(shQ807wxDlZfDa*~a`l)^{SF)O59B9b zRVaChMkVPUq&L zTC=%rELGH>2HpLThc-)$ zk*&m^f0TU+i<7|Oz_~ep1dEfv;)vzxgXEsU;^0~Of<1ONg2$ol&e!Bzk3?S2X|89v8r58H5|@f+l8$OmqXIRi074dKIkWM=y!CBoOp6Z zUf1ut5p_f|-t%qkp2>rTZ}b9L(R;2yXS=)KIhTxou`K?YPTy^h*OyDp^>hbLA>W$r z%(LXtFWr|r-IvwKl2gf&#hklZTll;h9OFne>m$np*iL)duU*+fX14{i+w@A*=fGW9 zi#^GIu)`vUWXw}}nS9FL=q4*Za~Gb)r+@K2^VUM_Nod}he7^cdYd!+aM&_*r^VZm3 zgZitaa=&@9xI1*ZJ$%SnzsM(hP#x2LqH*gx&yDccAK8#6v5~%KBVENdT1Pywk(^+kIBja?jk?V=Pi|#TA0^Is0GS(g&(h@31h#Oj75I`q-;I4gU34h= zc;>dXF)S0=0_L{qRXtNY)eJQRYosQt8=o~|zBIX#O>m$%U6*s-$$On&*hu`-+%~$+ zJYp2j-rP3vDE1@U(abg&{St1=yi;UmTeMe$9?fce27{RyzPATPs|AzRDt~2PUL_aq z#J74?s29m#=*$vf->>QS=aWH&-z|ra#gWx#nCnC)UWtCspS~VtawspeOEgGp>0-95o)luE&2qmYb?4Mx*rSZRr`zcV z&w>x-Q_P6#;170?pA~*$uQ>MXWMvZMO)@L`MDG^*81waa!^i(m(p`W_R$Olbzq@m# zyKZ;S3huTzfdB!5!v+#OxCAF?fbhqIOUv}wDvJeocL^@RJ!k?6?gR-IASBOnQYIWJkg$7-*bsU#oprOO#2C!3x!jb+p{K$?Hn0wr8_)Uhwf9(r3K;)jDw#FaX?@Q5lzajfyYg6^I?65QW$ca(tVvCMl{CIO17E4`Rw~4b=-QI6&<||Qhm)c znC?M6&-BuB-PmjCR0J+4i^kD=S=5r@+UDLKLZhS7>Wah)spI>_&b#=6e8VQaFnJ-7rr z@vdS3|4+)c=)wxO%D?c#x^&egdAHm|e*ATqflcX&C7ivB@mIDaPg^>xb{{idj!M+T zh~4pGA8WiN`q>VKjri>cSlg|=XP?h)L>A(nJKCQ6(R_`!Z~tIUVCa)8Jo{qK@ZH%s z)3Y?-fKyAS4;%jumzq9Y!CcRvf5k}6-MQB3EprJ+Mfb^H7;scLx-!^7Jpt|iNqr4C z#C|$soEp?|e9v+G$!U5okzHrXW#-{j?|7E|7W>j&A%;Q*(cb)IH?UM)CGWXb%H(JBl=u=#6a5nnkkw08*VH@WY zt~Qu1IBw?>t~UAWx_XZW-Q6!fFi!o=GW+-cc*{P z$OhTlm2w_u(NueLX*sWV#PH`PAHPdGh6m_@yU0$=ksPb0Vt41-fOk6&@9Iyi`5)7ket;=SZ>i-i)#(n) z%V6`O*Pd~H{%!1p-dVdAy}YdX=kusfREOlOz>g;1mX&%zmJ2w4I(&xDodYjggWvNF zAU5d)d#7-0!A7H1$tiz}?7U2d@uKPBAJ`V5C(}Q7 zt*4wlF@A>^E#O59W9;*j&CkzV>t=Jao^$XB^Al@Mf9KzK(EUfTA0z)nted*q_}(+F zX~1~-t_-(voj5_{aec^m)OgW=*AeT?^b=?&$L8|4DIe4rEHW{KOx&f?tI3R?i?!Vs zxYt%})&<2Vzvt`V8<0N|NAZqr^Z2<~-VuD0MZ6FGGw~|@*6|DDKjXX2372;U-zF8u zX9w7aA2(Q3MxwXrM*d&{q^EJrQA@tAT;<#{fbkq!S>r`H# zQZc%TFxDEVK}#L+V#FWe~?=d&H_x?OX#3mt+N&3d(yz4<>|k+aCJ_e472UTL|m z|BpT1Yxc)~Gku2X<7m@OckZ6I&pVFk!X4(TbEt2F`e~iYyG3=!n+3hU8-HJsk^MhmelnptBd0|^eAiS_1Pfz4gJvj$wNP^ z$T+_63^Cp|pRBG{U_@{0+??sr<$Yj{_~{k3D^>WzsxzV5>wU?mPhgGoUJkt;MsP+V ziBRV1pkRx{YV`?sPA^4b|3YWWX@-PdB%TJdFcR%p+)aaOD_S^X^#`T@ek2o%*k^Dv z35*YJ+aZ1EbG;*rfTK+uzaq8>N8|l)w1vpg_HTM|QL?gVhKH}{gk!8L42Ikq?42Cf zTI6qc_rA`x=9h1Z&vX-Ab~<~Z^tp%;y3h0d)OtT^Od8V;=jVDsIv4KsT<4Rit(?1K zVZ9D;?j8bLbdJ6Dkn>c%rg|Q-Zjgmu4*1*@PKrK_+$WdXM}MbzN65r?K3kHp$V2lw z8C`)MY}-q_x~|?)a!N+|evAA3u-ruKKVGvZkGHRuB47U{ zU#qcQ-gIs(?d*)PyEn{Nti}05-V&1^?8VDAwKsN2`P6jhUi3laU^_o;C$}37zTJV= zu9M-3&D80d%PZZx%df$|rmi5Ulf=JFm(CCq{UpXN*?b>(jyc(Q2Y4>LE9EWnAy0bF zJ?&eV7d1VD$s}juk!*_QiupdA zO$-|Yi%_S%>M*|gRgt6EUkZMWt}ViPY(|`GY9^`y=UNYInv)f=SAEU8YCh9g^PsPm zz8d5c28KP01JD`5Mi39si;OOSb?MbR;$y%iq^}Yi?`vzewRhRbz3`N&^~`Yx4E6kx zi_P<*;^DZw!c z5e$p?Q=aHmEB0Q(#g3y>#z$NTJ&L=`{hx9^w2EQAK}CP%uDvp(Urtlqe=0|%4wF4K zziS;v58px$tZd)oAJb>C6E3&U;TqU4`c`?~E!mJ8(fJ4SvHrx?hWXQzs#Y$_o{0U4 zo+4i>u!nYVR*%x5Fetsg1~4dz+Hm?ZbJmF0+HVV5ud~eAo-{;Fd}(`Ybd7y`dYW20 z{Iof)R-}51eEA?bHI!F}aX_e#3Y+JOs5=eE{5rq70m~mNF1Z=)sS97_bww|a02}>VBpwc1Gme!oZ%m^$sYIl zzp>M9Agf=I+wu10FRbk-9g4%O*W(t4S-@eYo~EkSt(3bRf=3kFOvP~RmtoI$AbI?l zJe}iQ-=1uJ?m0*K6*sv5wtVN8-Q(wMkL&YH-&WXBxc%K(y>oevmhV17Cr!xIQ|Fzs zYrlRWFEWijy2f0kOq}_ZLUM6{s{VQifUe)IE zT_XN#SNdy;=iEvje-l1wH(~eK19uby0e@iJ^W~hmzL05G>~_4^Z7Pn_66fi{sy4$@ zeBvnMuM}-`FKGf>lRQJF=6CH^$lw~Dd4GE0KDNZF^x*&X4d@jIV@5~(i)?;PPrx8K z#RkQ@n&Q4Kyo9AbQf2f{aOza_LzR2wzv4235rKbW&&GZ_a8@DKTRX>K5-Kpg!{uDo zZW_DiReS!c9KRYn0=HRMUrrdenY<-F6X*R{V_su3_xXz)-WYm%VSj&#Ub);E_fk<~ z2X?~6#enz2`$m@M;UBD4=uZQy{$Z{kf;|K~qjnD-!TiF`B(O7L9|P>=CSH?a=<{RK54`e>)trsHfLhl63Gh;6yYuh@#PFlq=!)OK{rf21{b;A~=Tv-59fMSorH zP+xJj5)Lr7JNwKzxnABWk1k+cT_f^#42!SM!zcKo+|N1AqnFKN)Elw3@L6-VpT1*9 zz#AOtY@Sz~YqIBtH`e!YKr9>HfnG}aCzsLPZ_v?t!PC(djykLW9khlup50n3!Y91c z_3E&}u#o1ZQ=SBm^M%j-%jX_sPp|{UZHMsy=jv)Raj3$%D=x)Gr`yymcapRi)uS)f z8@-TkDH2#59G_M7PlIwNda9*e&r|T>+34o-K=XSroo0{e88He!hd;@>{X89(doIF1 z`Q&@}{IK`O+Z9r>{WTqRTdJSDTv^1_4|{JIIh_kkxEXEJ}TC9H1{EV>||HXF|KN1JP@5&aB_@vwNF2AoCKU9B7dR*0F=~1R{*GPrqIp`Ljc}xEu4q0FcZR{+Smi-AKYGN7o8aD( z|4(~3GPVPq+T}|$>EM=LkGNK&{L_EIGcM_wrin?%+Oo^ksmA!i4145hcHcYZ_GIVA z31STk!d+FI?WY-2c6}$}`XI*@syb1}9=4&o(t(%H^U*qH>UAAXD}z1lRrK44|# z6vV{oEay)}e67mAF2w~#V~k#0x?NtDH^cwYfpdx_z|ACUq=RrHYR}BSet+Ry`#bhP z!N;YKUM1k;!e7M~=j%S=9LL8M?0A?1xl!MV+zW5AskSp8bDPsk=)YI#)rh@##oil3 zM%ClX>8O2U*WAV@z}uxJxEh|PU)X>0S-tDJ2Rg%U^V#UD&c${=);%J2 zEsiIg*RVJCe$_dGi`u+iWt?drz~8Xd;FH)U@Hcw3HE>Bz;g5IaX;O0|mhJ4~UzQ8f zJvY)}>lRhMo3w@dcg#=3Je*`LPBw6esnZGphnToas-8*R85!QhS+FzP_yzHxzp=4C zvJVz9w#W)KP(`_t{WZn2PBrhPIMnvenThT_yFQL5kd3M4=vHerWZdQ&pXazp?Csb) z2sXy9N#WkanXL{S>UST{8lc`Nx!emwRK!|@eXbAE4c9bjVgN`{Me zJ(w6hibv#_@C6&UdA2Xi_o@8yEzR>b;xO`->a5$z(&l=fVn`k~({DY8gUWl@(J|KR z59aF}vNpllcPV*OW2jCHf0iM~$B!O?ead>dCmdqp>{WWDY7IlcA?CaqX75(uuW*&w z3-C1hd)C-&b^jiPA?=D!!Zi9DjEp=~sZZNTJUzvWJ9-$m*^~on>C#?Y4E`kG34_B; z@kk9t8vrh*OBq#^9}>@Mm+$d`)bHTqDeQms_^En+pR3UM zFWNgRd3T&&V(WS$nFF;U@&#piB3+S<9napFV4h~kFK7Bxw)E1@%ah4tVy+L&2FowK z+gLWsiR5k$@}nD`+EQH4?$t5yfvFK2gh$BO)&sB!Eu7a)7!v*C{BAL_@wIEJ4WT!1 zTCg!EIlJa(9~>q}hert>vZAh~gnh?xMR&qn=;ff6EuQaW2Sx`jyNX{e^f20w*<)|3 zIhyHtwqO@;Np8+9TH<(v(O;vNGX1~?#D3CftCUTC*G24`GwI~F=-0RWK4M8DXVbYb znuR_0mGkIA>-WDRuu;;O`+}({^n8T>$cKA1nh%(VgPb=j+Dno1YfpaYu55@e(x&{a zUQwC8LwsX%n5ll6?f_}qtkr^j6X)GY1A{@?Y?U-7Z$aaMHAdyHk?ZNL1cZ$OT+ zWb>BxU_X5A6lbA6z-+8@$@TNr6>k}e zr1gZWq4zVf-i%Jl#V>O>!;U^sqviX&rsaHpH~aX4BIg@~@D2IEMHLn&^ILc(xE6M^ zGuOEe*TVN`sM~4KZ4EKchF$=T1g?c{oXD4%n83A&=gjo~S%^Kka9IU5almCort4x& z{c1+W%P&m`xU9(Y1aa}xf=bX(HScG6Cp9;EDChx4XCE&fe~!65GSx>f9e|I^=-ONz z1I!rP%~=m`67Y?w`Lw@Q6@$FloNw;z9%ui;Cx?~tPPmHBI)-iVoV^dbqSjf@eS7>^ zpMhQJ)qTLN$h%MAgU`@gLHrc{Y6Ch5J|W`Z%7?{u)ZeJX6oX{{T+WVJz}$T#PC77l z7W+L@zl5tgr~jO}@FjXHR}=UW9A`uBnTs`b%GfXNzkCUJ68T$w#>mGR_WNG+^h5UZ zUEck@q9uR{8k~)@ramrRIQph|hZ+L556lK`m*HNI5||BkLPc*OnQYgS zJLWfb^=a?GyS4ZSWY<;2uoE^w0*fIxSBm+=Rk zTCHlpYbEYbhi$K0`zdO-?kfKiF_*Ew%OmvA8`k79bE$81c>rB? z3LP@l`fNb&mj3+*XT&w``wp4Fjlwsmi@(gEkK6JPIUjo<)&cSrLisk|>Cc{TXEHN~ zeR)dJm3K%3zN@gR&%$fyOIKw-RC~3R@ES07HGcR=a)~`zCtu=*xFIY0Csp+#FX1QI z+GD5box)}#2M2psJXk>-Ik3e79;|=|OD~%dv9eB&6Xlew3iCEZ@1}HHC#j}QIKR-t zFu&t|?~DC>>+D#?o<1Ab2EM8Ce6qsND=!i&e$n4z?)*$^^UtCKH=V-E^1JPuZdT~2 z*6HEW~0%o^V%d9U1Y||-p?W5*+ z9kwf8D%|T;IdnZB>5LQ1;du5LUaEkH1~2tg{%$9E*cz?t`ReBSWar_k)&qvESNC=X z`*~sK&^yMvaPQ~Pg;%o8`aRcMKEJOu-Ob-_cUCMTkFd7uM?T8)><9P>In0~|SP|=} zz}huVR&4l(%wa;V^`d1v#@#lk#-S5%TB%P{pOoPr zB(Iyf?{(^`H|d*5m(GG!Xo`{W_p@9sV^9nghRb`YA(IzXW0C5S@9Y|NhVEh?jOQQ! z%HG(M&Kj4tVE0x1iMM=Yk4L=8Q5hQ!CQW~ac%CM(63M&daT0q99)ixv#av~}t-{$6G3Hfg`Ef^KG{xJCTzcww( zYtxFJyReMb=03QedCkN9MMDp;ezj-g)S-=s#h4ytBKcOl4!3tW)L#FDZ-Rr$S(>uX zGjYH?+Bs~JTpu?WB?IqNz&iz_RMYFT#`aKa!`|P=-nqqGOk&r0FLegBaIrmgJNxko z^YeoJc{*KtmT{hOiJ{+$nzd^3k?|uLIK~(4*9xtAJ23xO`x{4hdEn+a8`*y>6fWr zG+Bd>(EGFE?mlmAf8id7nt%LA;mouX@FRs6(_uchezw*fMnd0#pij`WWEp4fX5Q;o z>&U0D79;Feaa{8HANJtJVlaPq&B%`t?Uy_i>t`c9XHI@%Z&%n{)8zM}oIReVa0Tp0 zehyBgP_xE3k%F2JF`EFJrf)92GnenopgVp>Mt|(4@6# zOm4tDvW=hfyC3NOc3+dfsPBWh-y-e-bAZDs;Beyas;i-Af8spB;iT@S>3qf6<-4tH zNWX^`p0XzHl7gLJPRZj*^vQz8&2;*A;-&wiBgS}-D-0ZydTQWV=J$#Z+3Um3aOVs^ z_aVPqh;2U8JM8D@F?6rKXSnO?oYE1ot9E$KS+)opIOYit%crrChQz^}@RZIO^WJ51 zZE8f@YbX2cPV@Vbb4zTnyxbmHl#Ujkgd5E1Yx$9}9rY@?&$Q)|nxW#pCyzNTV&B!S z!;e@`7z{C_RPQ5_>bz=^1li~aFnAKj-N1RW+dPkg3YK#I7Y&|%PCG0tz zPx5#HUmw1B1Lu>TRUzDF;C!N^OSwn5P(#ihuE4(yd{26FlmXw98p$%K!Go7A^*<@Y zBZht|y*`8Zo`Rk%usfw5d$4K-zNdiiDd2m;qw0G`$H4a#@I3{5PXXUkc*J!CltaU$p>(9`w4=N3$02Jq3JE&bpfZK{d}+W1H3V3B^@l;CrG^^$lTr zu4&+V3izJrvpW1wogY*Wk<$R*Q^5D6KVY37RyR*|y$kE+xvn2cJ>Yv1L)2f-fXQUf zHauU$wHkV8Gy=Y-fbU5^!baHG!1omJJvsM$&cOHNx(#@{hBK|74b`v5Q$O9>&p+yi zX$d@S3lCPzG+-gkKe&s5APgAr}%w+D0K za}E13_9s~`)gM;g>qckS9C|ffXpjHS{z&YxiG6dxEzVMxp3A)y2^uLn6>@HfFts(BTAyTrX0vxlCcn--({x3r%(u&`& zR%7f^9XcO!z~3scI$b%Bragw;&UMbCPZx9UcG#$YfUyy?-Dj0(>##9P`ycm`czM74-xPZT21~qc zGuOSxbFWQj^DEV;#VQYd{>-X6yH|&Qx;40wtsZL=zb3~EI8(OGt7^6aJXEUg zFjEVc>uD;MYs~BYa2vtyD}$j6aU0pQqhi;cY-cL>oZ+Lv!N7Llf3kCnWaD(ed5q7*_|`t%$k}rdxm(lR?90DO?CE_| z@hNh*jraVEb%R~OTOuCl4*I3fI!qMH6Ynt}S*cekyF)JAKDjv^pg+_1m4%TGP`z6*Erx)tNj-9`Pe&q7vQ_|9FrOuuGoNB^eACoD`em zA7ck_R;ICMKW<(|{ok@&8jD;1xa-+Zh^Z!Bj%3UYWR*@^Y-FVG*)vn69r0=`8oN3X`Lll;`a86*dZ z@58kua4q^B;H5KSz8c3|GPieuZNVpA_G*xq6?6Qal_+;-e`WF%o$$AGAo^1H#G3YU zC)t8;uh$fwpeB5+xwlVNVJ{7^n{Wx~QB}deUB!)8*Gp!mvonWP$9-#FpYrYnU4}zQ z-SALyH9PlN@{32v+1l05E?48#2|p8qxy^VaFUmLA*zd5hH{hRa<2hcI&)vxPVB-C| z6TZs^#QtFnotJC__JUzOCVY>K2j*qyy9~z^IC)(pT}`rDqs2Z_%cXzA)?vz2YqMJ9@~O z+)p2$COXhgu5|z1`HFaf#BM5V;hK1UO&^At^ljB(uq>oeWC z`k8y;?SZS#oM$-b?dgZj$0^R|XZbQWdCphu>0{~a3HJKV&Yq!6-yPS0Lt#V6-@1Ox z!Hc0Ka@KhAYMx6izIS?*eioXLiN{B7B?LS^_}A;~D?O3fQY!BP9v`;Q1bFO;Fluwihn~Tv!k1<~VO^31(uwT$ zSulZWImpr0MV_2gRFn7Zr6r7?o4<&qy+`c$R`N2N&s;=?;9}I#ju&5^DBg2At)&l) zxWTp766a6A`J)GS6Q4l~zik1Br*|xw#O>q!Q}5@wyUvMU(nsTl(2JUeb5J_6g{ zz~{sE!-Yg=G{vSb_Ka{ba-LoB`F6Rnv-TP1Axum%h5R-vQ? zAL0wI%g5QycmL|U^ZD-G2H!{;7xu5oe}T_sf1YIzU0Af?yA@G572&ajudPcpJYJ-=$;VZN%fs1l~ri>?qu3kxVP<^3Zj-%V}gr4#nr; zZeZwxoJuMFKFr>omBc=P-=$qRF8##m4ZJ~-dyZ`2xuCN@^^Cuyck$elvm*R1lQZ=W zv0i3b>vOR6O1+={;mM#$BXpq@C_cibA=S1_z`ox(F?JLICBOrhsu z@2^elp$(h`zxP~2{=15femD>Mc$B!PYx)w@_55h)JJ-(^o&v*Nz>K7@PPv?V9)6@7 z|3T;A8Pfk&y^+0wXDGxoV5aw2jZE(@4!ImT{xHq-lo`M!&Gx4AS0OWJS)2Z}C=W>C zlIXUdI2-O|*DNAGGDzm}3CU4*5||r$y_4L=j(Xl%Kb?+-wUL8W7hsNHZN%W}>K|rf z_q5AaKA@KwoWJu)PbRTzu`Dvau{B&mtPQVFI6Lpc3%B%pQm0H$^pU-7ym#!GH$Odb ztYBDSj5@pN&hE4>mc3;abfnxhMwUP{V%R? ze!!-%-z#!R^gB6*P0?dPjRijlHYM3y9y@XGPx?khfZNGs`3$j>Y0+LzF3R9wtf@K= zTu9Sss|+qeFAL-RH0Zllhas-R>et2nrtu9^aU6Xn+(YhKJX4Pv>jo2|5BVrOL@ve+ zGv}Ib7it5^Bz#D(_aA%+{F#0m&LH>@eYGgm@`Zptv^uo0Tp>qqnRN!khj z&GE3%asQC>Zi)weNKf5pPq7(sQ|ozYzTr1uL4*3&A$@u~(luo}r?WEWP$ zZ>4J7tK<52$_xI=wHKn_?xf$=HAgV&dZ@IMzmeTN*l_prFL(9*3+Q)TK5Brb^z6sU zV$5&b8*g|Qn2iKxL)N#Q9Oztp!5sh88b;4~VdD?R@pNJz+jm}LbGmVY)mp{bt&WL5 z(~^tH{H9HpnOE}+*O5eA$KiBDjLU88xnmy$9EbEAPFZ%;5%Qk9`PMRYz`xA-+XkK= zIXHYu2A-dQ=SMuF)O)OCQ`Gh7s^iKKH-YbmD^jaaI!EfgoWOtJKo@r=^udBg{d%~y zImTLFM-N{@N9;ERdQLGWX-Ny!#Gh@Ky?vGg)Lh}>lrXSKXl--y_%`pB#z4pa?qc?Wzy0pE`p zOiit3UEih#Uu9HJ|3F{Y*miZk;52x4HQnYj;{7+YuRr%(x0u6a#3P33uzRzX{g*nw z$tT-uN>S0{tClQHSLkzD`nNt`Rcjndy*8YsHMx;G?$_!3=Z=1#>_c({BhtgA!iebO9P3-N3=%ka$*4M6eoNLASsW&JA4m zbI*K+@v7^eYp1Twmc}Eb&t8SU(8Y757fRm5@0CYPkshoSam`V2@mcP#5AE1F)UoPU z;%r{RbHJAH)8GfQL46Zac2VZdi)6{TPw3@u_&je~GkimA@1TY&^y*%JDdvZ7NSw0P zi^t&`g7a#@ZxrRTX}8DO%!8(foN4A2#sr3ZRBudq0s0|g!r@EUz4}vTYzOOiuK39o zbny)Gex&PMBKClb$eL&LSjH!ThfN3U5%_7>fg?%aNc4j4l-uTQ_0KI>RXf4i3rnJh z64aJ8_=+tC2QN=BBre|)+v|k4e10+K&HC$y)z1K3i0cYff-g~L6N)M`Mq}T8bsjCa(IK%4pJ&*a>a;$z!h1yf^7JK2r zr@;KS#NtPj_r(?#8q-uKqL4Nn)C-!en(1-I4!prNZ)Ahu0)hw86VcqOoq(^Xso~Mf zh_4iTxIg49IN7|uK}O}%^qA_DE3gZn&D9dZpl(d|@Bpd1mP@ktANIa#`^000VdC({ zI+u5MjW6U<EvKgj)QIpK=@>W@m|^vPY`#^=GF(Wn1{y8|=RiYl zL?0V-wTx$9k&HNN^-ygmPiC#4zfq6RV|jb3>&y`oF{h(&lr23|aZ!^sri8H+o0Hhc7^ z-e*qNdQ)!P8uPv2*<5QMxxUDSA^_UM9PZ3kxZC*`@r5s>t*}42g4fW8N3U!@;Wc0h z#9ZmjrLrP{*HBwmVMAAYHXp2p_`*bbF;|O|$DDJyqWw~(`_3^Y@GJgo@9a*tAET@E z&ha^%^Pc4m&$5VEO6>213s3Kqns^R=ck3He<_?-IdMVD)x4TjDMVtqx0a( z?2+B9<7MPQZ!K8t0e+ksnL@uVdh(zCz85|DTkmnc=ikEFa1Ghr+kSw@BJbmq*t2jR zznf*QF3cKHPs(rf2RuM}g3RDwRN$F%dKXt^+D_iiW~et9N|tc;FOcSuuQ7oO(F3QA zdl-kA`QL(Gyv*LZ-}uD%x4ksU*e32NV{hY7BVwKhjnj;)`LbTZ8Za38$%mcuZV&qahXNBd>Wmcc zGQY1lzs9pqU`hCXP4zzdU73G)68g4C;7MFdorw`^*x*SLcoNu4F(UCic#`Pr@wc+@ zo;BDYo1mZM41Mzh{ALkw3Gw|0VUY*;L`4$g{O~3)FVmcHgL1B2J*D-TF~>LYp?*c) z7cp+;1NT|4CD@Mo!0@TsIO3Z4w^Qpb?q&V=v%Y_|-hZa+kI9Gi56fW;2c6|&jn1Uy z?WL`=COdIhFLC^6^!;Y;4|f8$GJ}p}JJX5yfYc#Xd$tQcAo$g)K8#iT=v5dh_KdR; zA5f29;A(amJ|I2SOMNy=xE%cyjPH!O{cUk$MI-td{MKIWws=Xv2NW(eu6Djor5o`9 z$$i!IVynq_$*~#ufaKw8>Xd5%9}wA-4>Rxq$*a`G$Ljo(Ivi9z#NP4xSINCKoCghg zwT8S*Bj5vqRd4V$8@;?HJ|MZWe%QZ$f1AKQm?_uQ6bI_)y`b--bvnV`jQld{Ou|>@ z^QZPS8yilfp}#@{wso9+Ii77aU3@wh!&QSpZuABypN1vG5fpCXkK+gulN|^9GR>Kg z>B*DnOAn))>T~JrJCu$62|2+Vq+X^f|5lY-3+hYpnj7nzpVYk0Z7#nxE-?={gYW1hXa*6bT52B`aVtbd3^!skq`BrnWP3d z;+7U?cf`58AC>~&kKlMk4y4MyWzUnDzj_aRKWZ5#_}c{Wt{HIm`fJmjPw;0ly7q0) zt)GZI!Z2**02{t(&v(kJ>6d5i#f?4l1$6k2_SqzR_d3*@y*u9fn4J0slGK zhM{54lxny~^k!)ASQ_F{Q^a}AyLbtXq%!6VKDIaU_o!{@A z^I)8Jp6aLC3eWqn(GZJB_!B=k6E60=PdjVy?XlPOdT|fjJ$N@N`eIeZ{|4pI(iq2% zz2?I?d0X79*{e@`WQ<;h?2x^)nw##e z#P)cs@qEyny=BhSRl@L;1tH;?jBkaTW z*$ci%{;1qrJZ6eBaxG`dY2ImeXIpAt;qc)TsQEYl(cZ${1JhT8J^4#~DS4nE<~T$K zo4B_IVB8yGW}|GN5$Dt(f3(@dCvV3;yI0=gVxPU=?;_6UO!gBQSIb`U76Il6SDEpn zb-G4OC$Mv2y^?2&L1(C%KJo%bBNtj>vsJ~g@Nv5+s{|_&t&Qpw- zjGW||mUWJ=0n>6gS^m*_!OJAq7@zX%U}f}~sEBz~)J6@9)#*3p8A|8>?_C3K2I9FY z4$05;j&L)2)T&ytrjyx5Y7)dQ^(%AM#9s9L=<=_=e+fHpGMnWhpIgScu!%jOc0$aq zU~?7aLhPQ`_WS0si1M;&0Ep{tj%Z!@T<|z9$C)J2q1O zn*2sQ34R{=;yk&Mo>?qSowF&~Yr!;#f0HGc9zH1UXwN>AoQr9N^~K!opqs_CoFUWL zsMF;+r@%xs#c#XG-Olpu>9akpL+1Xg8k3DZjOg1x@9elhyzm+G`;zg#vAFk)9FA8T zF<1Vi@v?EScR$pKSfy``wX8!)M|@+vV_ny>HV+uz8w>c`_QpPjo~>#w1KUvizVhi{KOirL53bN^i#o6Uh@5LWcdAq*7Z=aty_(^j7_caZN@t6mhG%{#abV4JYXzn z%^#u@P89$8nR9d9$d7(<_9Q%0udWWB3FleRGk%CKB)01uh#a%Ok+UA5 z`_|%<+~W6di7lRB4G*&iCXwsNEwVp9az*FMopd~|Au`-i+sPNV7vV}0xRL~}M82n~ zXKM;ypeHLG+UNb|G*0A8&j&yGp|f=n`sMqglRRFu^z3X~#7dyz^9Le9Giw=Zafi;KqaQ2)@{<>IYaulT=Mzzq7GhQ|<$;F@_V3UurHjmL^v47T2-Ftwn z&t@N7ZSdR4R8>E7J*~XYB=Wf~**rr%!{5Cp9+L76zSSgg?T_u-U7f!xxy}b!ryMKq zQ4_OR+p}$2w8Zl8_}a%$_6_K{+vHO<^-1mE*XSfivTfk_!_8SI{6Y@pFlR_XR~_Jd z*_kY`h2_9XSleMS<-xL#Z@f2u{&o6d1!s?a3L^@mNdLmL^y(#GT4;e8&Ncn#+;bIn z&z0_bu4_;Atmm=kS0$TElE)Yq*wQ(SLx&EU5?1rBee^ku1D{8&jq?I7MGwBIF+UHd zQk6TX;*jc=cUb?mi!A2eaS^an*=oCIsdz!ow=G~f)iq>#ThKv+bj>=xKhyW<+a3?h zwq)=ky6mUM{sz7sdBS0KS1L!Eik}bD>u>^m+P^!)ZlecpGM+ZRmjif>-o(qprpe@G z^;c#W;pK@qLOGTUzAx9$JmAP0j?X6ltWT9QCHBc*easa5vIvjK8D8yvACo`*ir5nR z+!&8o$K}}sAK3TzdCyU@b`!b7yCY_ZyU_FE-BG_f2p2e@w!PteZt$I_!sp@#G2mCk zatG;!G{)A-SB$DK(I;{_kK5B!MX0e)#0(z@$rPc?X#Fyxsr~NW0V_##j>7T zd!J9p)wizqHQD>3$n4FWJ(%}uFn(??o>H{S56BU$i+U~nc*zf}OR|qM{Q$PwOP&$V zg|DWj)IPo;8&Z3nmDiE0FY{48f*$0?ncfj!PuPVFUXf;c*5vB33Ox%4#9gMwzPI6< zbSV6mOg+pV+?{OhPVS;De3-e8Ts}YJ1I7FXOiZ%7eK|}Y?CJCHFv)9q+T-nW)(6}^ z0k@A{scQGE_uPC&+&uPw#wKVdSLS*6z0cs|3HW%#)Vr`#b-46?IoN(&eN*MPI&umr z+b;9YSrWN-Blq8jbVGy8SJ2r4ev5#kho3(j{*Rt~mmk!hoW_nx>7%Mx zODJ!423|mRV6t$H24}Chxij%GXW&)Nz?QiDndSg?rH8G8Uy(yEJV6E5TIkiC!>{0C z9qHv~Zq4+twHIcvO+OLmncIAwX|FwCJmOsXrfBOeV!t}GR%XvT`|KzEB&@?;Q9kJ| zJUqQvIvyUrW|i-w79QSh7uVcF&U(EER1R`s8k7D>`MenBXKa+^)U3r{~$0+~DB} zczAHLmf~e~^@(*Ds1bF&`a0y^D=!ilmjuQ|{H`l*)Y7l3<7ZRv(spusUmNnAn!Z|L-=WJMsE{uKj*R%IwVDvATnH=DB z5I@2}R$6~}6XOTEc6R%C89v?0Y>(aSceQ_i=gLslNj`9{PKYvKJVzH@Y!5HS9{oC=N%qKk#%%sS?hU$B zERn7?)*$288Vi{JGo5d{dEcY#rOnxv@{(k+!DgAlMl0k43o)k(-4oavL;6(d!9_+M zA|HRT4yR>5yIl!97Fy0X^~secos8zcre48ZM%6Tk3oDp1xEoS>m~=@pNnQ6E(hf9gd`5FR$tPPIQtHdg=?Z0pCJq z<=K25zNLrFhi`G6={+1<@`%mdt!cfB^t)Q0I# z>pn}lHZCIf7=gzfVDqQyUiDxx2fw#26ZGg^2!>}{aig*Ldtz>~K{lTs+bMtVJz-E_ zV$}d;6}7)@{TRoI41=RKGXy^|&h5g%RtEQ2oogS-* zVN}UXSsqLt_j8U-A`5al{K|~~!vFOAkBVU(BM$V6d)J)1OOxwQeP&@Yva|gGyTZ?_ zBs;JzcQPVI;~qJwd(96l3%yh%uq+8Ii@uM8au=ysBc6Bb7;B36v6iQ%!yMQmypfjb z32(TO2_A*1B`A5nwa)nb#9SOb!M{ z&*z|zW!dYc2Lq!F3N@JqCxk4*}TrCwr?9boE_-v^~k~1 zMH2>A9*a&qmOg}~Q#S)cXwG6S>?=mqIrkX9U|(|=Yi45152gn8O`Ws>QzO3s|7SnK z)x_SgC4SrzuREO`#5qd&%3-!^0S5~!NQdAElCRf;FU`fI2VpvMexW)9`tyEk{HGjV zhyEzxE8ujJU(k6m-neEuRjp&ncFYo(oyf;4hb#X=eT1{= zQ|Hp^o_j~K(~L1T?}Yn@EgS;wADrD~kINqS&;RfFQVc{LoCural{4q!Uvj% z^U2P3-tRYLcQG;?`2}$A^l*l;S0nD7fP06&N!d~@_DCDwPE(u}FCE*iYEG{8EP6@e zo6q@K1sz+I^UDjq#h$p39ruI1wU6hX)BZU>g|DVN#aYx))O#FN`dQNZxx80V-tN22 zqSE7oJIG$fGA=(;>WSxERbO|e7=-yw7Ie=2lH6`%bjY1tg>@U|>%sZZQUA(@^)ehN zw5B`N&@fG<9xo;v()_u^W#h&?e$AkL&8>Ws3mRi z?WWrkxmc^-DApAZkop4kugBNoK7Z_Z_~5S9Z`2OtHfUk$2q?Ux-{fW%s>ybyP zsvjO?Uv$Ytu7`>~$JT9IIjmjGTh*Dc37vHmJ0kjZ*GGSpu3q1FCevSX-sO0@VgoY2 z0~>2czTkfHEw7VZygmW1kF#q?j;bj)J!(&;_DQEaG-KP5oj2*@6+E{(Z++Q^)O=_B zngMorOU}Df-k-MkMe_R2>hH+m;jW3}M+^fWglFH^yL|1PF7@*R?}XzAS5nJf$zV}B z;gJHzE8I1|K(Ep&pC;(j5a7p4XM7!B>y+eT`aJf&6esO*Yr)tgFg6K{4ID-VE*%Ge z@4(n3FgD^3Wsd_3#)f^Te#f`z-_RS%DhWF{ASl53^k(IhQsJW6a;VZ1@ z*`M**zsir{{RwZ8uie;nxMN}VGqv0~>>S*Qx%n5ln#F#+!8+=NEf!TcXS#fUy~o%F z@GN$Sep_Vl5cYqJDP3<4*B6`Gl}v4KFT$%N@GACH7tR9a!TN4a58?KaJE;fUKCovq z)Ht_djbE=%WQ^6~_6bY!k8u0IqL$)vHT7-!RT_AGX&Jr-5WSv7^|(=3#3D^Foj69q4Z` zFL+Z*eUDP-vKpx@z}gJLL$|~!M&LbK<+uK}hI3wBZ@E(j6Hi8Nvd*t(seUP~WJ~)V z7f(1bAC&{?^m^dIqLz2$?c~?u?2E9;|G~a_&6)ElJ($vi>(GM-$!|uS{mSI)0&~W~ zbv}>_bNCQB-loWteVqw!u{A#>A8Q#$8^`ud_v|ypb<*S=&v~-7T0z|7GxLh$1};W4)9#h&{OpNENo%ge>NI_1}%ZxR{$)_ve%oSdm^Wo*ZmcoRN1zu(#Y zuXO*LjXRB}jITU{K11s9r?5BM$=#WLG-M(6H2cI)I8Hq-)LHrYsI%q|`dd+)=a9bT&`dZ#cyb+bQR;51-7ZCo71*Z0qlnoCRBX zw_V+La;k?keSRA|<-W1AvE$_`oab9Pr?<2Yw`UUkzH_Jle}?_Og}hF%Zg<)ZziCgu?K$9ZdRPWHoF0Y-4kv-bfm@Q>w@2Y{rt20pW% z*OAlrN$+LmVp(y)e~W#rV?Oc0;1bATRP;IUEO0q&rLxB>8~KG{k@(>Bkn;yOjQGuv z8XWbp&RYB~@S`JiNsE3VOKF2YG*j+EKSFYMKn~B&4mg?S>*pgaY<`#1=K+t4I)GO4 zi1TrPk35h0x{9r^xM#hEofG@G95c45*F%SXY{LGu%J1lzE9BNA7wGlYIrh_wJy}kn zryuh?7p8C~^!B3Gb%wEAT9garcyWy5*;%n~!?SGGlMEbz;`Qoi`eyKn{9QcuEx7B; z$t=uE0`t{F!aV8&7~aXQ!w;5!a<#;bjtd8Gba3HT?uHlfcWsQ4S_wdv|;;`2JdY zH8j~+ov<#yPMu=Jg2A?4c1!&j@dIcLFnftTI(!%Dy5To17cP6m&?((`eFm&S+QXOdVNJWB%4Vqd6jO9#YK^swfK!l%%=)dW7p`Af%H zr@FP)rz_y3(Ra0kqf=i>WMC z?$*8T|NG@hrzcCguWUKKzFe;p@c=qwdt-Ha!@H{Yt*QYWl*`r=$KMZ?%j1v3(8!}% z2bh-x<^?{cO!Sb8eT-moaW(aI%MLsD3by%g$!G3=caEqFduzm z#=%mI$Hg_CO*2&@LuwLoON2Hdv!`Bu+&f@`eqJ$~ih_-De?g`8cHIa4xq!}_y1e^<7LU{ByON5wy2 zJ6!j2-+9=(%;sIkQ;A0qw(XCiS_NlBgw`6_Th>4 z>YV(inQR(8bVExY%d@TH7Cz@5y)`@E=RUVjabwE!O%q3g#dD_q+PlEqSWUQkW3nN> z&4()R1Ix+y8{CaPJQcav3j3j={;c9XD{x&EH31bp11e(omDn3dzq|@xs7m6iYRTct z$u+zUE(DxZ2D}a5v?{-=_ZNADw_)>%7Z~t1_%C2x40szjmokC3aqgGS?^3J?mxtd! zXuL{(VQ$p^*62YzS7aIHhHk3CXYpakHLn4tpsrU}J%PKSD;sLn`f>M-PvCA6xEu9! z6BD?bUjBPiakrRL-_W|@0Fvt)3JbyR#a`80+KY#o&t2(c*iicd2cGlb2=loBT^G4? zeoe1FpSF`jU<%$7pSfr3jA-w}?H2NU>fYu0*P=(yPKRK>hHwJ3%lqWMFQgaep%<5y z4_HPGSAt7sUU`AYZF0G@@JIRu=Z{!*OD?>VK>FDwjKHC-bn2o-`+WkkKDpcf{V+`&^wZ&SyHUB7Zkev`vi%$;xqLc=_WZlv6{aVF=^?ZFT$qn;Jo>ozjj#prsfi`M z!JmD_d(Y+k#YLnC^kA4|Ki2KbW$ecUGsWle^e^_6B+UKJT=faf;{LJ=gCm zZ#f@!=SY7$J|ihMetH`AxiC^c{X7_zbmpbPs+ZxaH|^dV}@{?s(Vy zop)46S?2WkJ@oe6MV*|bdU$m7&T8R#@0MGWw{!Z`RKV~2+kC?QB(M9-UUWU~A?Izy z+z-N`59ob}yNYZa=NJi#6F?P5G6=7YX-4!&c}+UEQ)`t6y%hPta!{zxj` zX8r7;t8#s!>6#_Y=YYAG=z4c}-Zy=>&olkTKIrrQJF$0Qf$&#_o?X7A=UKt?TvQF}6dk$_WdDXw+h7!1;1a2sS z8=_k(`Ve#zbx`h{_UzTW_(AiVlmB|=ea+*U;!eLHFHx@?$;O+{9-88r_wtUgGH`Bc z*Tl}R&Sy`SaJK%RXZ?~M!Dj>~JkHrN&72nHy!nWHQYHt;4<)a62&=^0eI}Q*ihVx8 zd9-?-!rEqH!5tWkwAXJm_S1zMO5lc)h#Q)d-4`*YAMi+yVmDrDCae6k2AP2aO5lJJ zI3TqGZS`tx@;MHUup4`=$d%v}wFj1?7Z&Be-~=t7&oh0KJLPlcWp;iYrr+|<;!g0k z`u~JpKM4FsdQz&__k7Fye#}cPYFx+GIff6jqx*c2vqA06)c*KT44~%By3RiS(%gKP z50vBCJ$KqG@ILC>_qNPLr4I!f!TV#q7v_fd zFbG$t4$-s7Ck6aK0Y8v_z1{GC^wr$n9sh7ShqDbQFKpwG-bdl?< z6=7J-C7g~}Df>sfFvc;vbS~Z>{q;KKj%iB|vJpHpZMsqKM)oQ_8-B2!b9<-lz4u4y zRI-D|(PtxG>q2Km>TkQIMY&{F=z&y$SE)K{1K(U<9(!e1`enqs&qu$UCw8(UJ3uA5 zzt5&;!7Q8wYAUV!UD1#5{x^G0I301dAu&(<8UAgr>s6+P%G$x{;76>hk!`T2W=1@O z9wHsSTFT1F)aYmIR%e|3{1BTx_GN|FVb`gx=9l#Q{iw6*RO=nj)cXwFK>=@&{#VuT zF#XKVR+CT$JV9#JVZYeF|6_AbBtHk`WqDWM>117OIzG4Od(MEpNnmfp%q#e^LjtRk zyhB&7Zv4kHtj>Nr(sL|CPGNGyLDjy}Wk;j|CSs^OjK9AzS(u$~JiqrjP)_?}KUeTB z@HP6t=-I{Jfvpk0qT|UrYz+>sYOgmYY>i&MLBA1auKQa9wm=DER_f`^uCym$YkD>R z1OERk=Ky?-vn@}a&YN^bsxB*Ie~AIpUHFUwJ|lG(BjH-l`;d3P)%9U(64)ANbEjNC z)BDI-*!B*OTGPl4I0qen54&(_{`6&Z)vw6chWwQe*=?K3MW_DXxf=FMJ0UG*lt+=L z?{m0W*Sg=_J-|QwuCGHD%p1M4HrdB36z~e++r>Yl4)xQJVBLo~p`eW&BYA-~cvZOO}hg9y+Ji+SN*D$%{ z7hWe>*j9tr;q#VcpdrpXP0yDheMmY<#OvT6ivE-y3SH~Mud=VMFfJu0Q=NPBc=y}w zi<*4I-^gaw+%97t*GPxygxq(k&Ze4J)^z7$&Znazyg%$s0(+Cd-q7oVYLE)?X#ci< zZh$w#FQiXV4bEX0z9jWizX|(!)S39Ed#_kek4OH=kRr%LJ-A)7F(s*MyTundkK$iG; z>@U5Y3^*NmjWU7Lfzzz(c~Vc{bm)7reRl5>?uRph9aR(S9u+qffuc`#i%*uq>}K*Vxj3=Cn2pd6Y1owP;|Zc;s`N9iRr7Nd z`M8R#;0Ovhf}CfKfFlUk+!X$KSFRE7fcO0y%*0WyB{wafF;Ldb^R?dLCoJLZ#d)_k zU+0Ng?qpryZ^Yi<9mEtbqdP7kJF~HW<|haEe-zSm)c0m|Xs4{x!@Fd1`<`uS`v%uf z2;L2+53E@`;PeS!*^`@PZJdNt#VGP#uAXlh@c9IMK6=oO$VImBHZ@_9)k@%3h-c=D z^vpH%=VxRb&yIUm;feGv_nxt5E}k9u#!*n~@_&+<}a+ z)xNbCo_DP~++(Ax%7-NLu649=9o@4a-E#)rI~P5Bwd=*&&6C7-Ru<>j(tN?~=&RG! zqoxUmq9+5}+jc-g=m}Mt>iD_2d8_dnwJ;o4A>p<*P4DzQxe!6J~3Vi z`z+Sx%GVC0jIb} zGBq#V*pEKu=Ebh@cFSSz#$J6$PA=-(h=ZPFzs*LDC-K=1=X<}-2ant=5x00XS<}Zs z{{}sv$lH=+V>M%O`v(6H4)p1IEXxggr@wjz_1k*2s>NihFGQE9$4#E5tInk-w&Q>O z&O3ev8{crwX69#EIiR=LA={Y03)nz=lChP@#j1QHxS9m6CYj{ld#YuFSA!dd`4vl8 z%6sGUfr}r&gJ;v7A z$-Bbls7=6clC?eGK-sdMm%8tF?%Q^z9!$@@PZx-ltN+jFo?IL_#~0TLH}Vl89_L=~ zI8d}S>>gSS!hjbBxqb4fArms&7N(8Hz?o@3V4ImyH^6kM!R z!FD(GQ7HL3`kEML+Naix{~-EpujkIY*jum5);!F-EGI)C#v(VGCon$A*JNuSI^>t$ zl|BzwkbiLqG1^X8*JohNBPKzNmw#{0&S1YTP11w8JI-j)vo~0?*?g|zT-c4Sevz!v zxxISCeVl>#iS(bS>gz1NM!xYAnX^W~PZaPI$yci3aGplY&ze4qr$`NDmtJm_XStp_ zME#s=-hWtZV|MwdSy874yhY(hHW}U`JZJ1c-^W{|e^C{0S+!Tsg1bnay#7n%@H95a z9rSHZZ{A6-J}d8fis;xO^vBxt-`ma#b!eK~mwNe(!eZN(?9J8OOE0^C=LjyZl)r&9 zbDquPnuj?PV$Svx*F6{>;csMDPc`wH8S;zv0KEdQ#Ks(svH4^UF{53J4E{8y=eqKK ztum0wm}`pIf(NtynuUWaCG`ZFqM9$pP_yC8ShuDYwDdTzLEhFZ3YvN#g_zpWS z+-aY|`3KxZF>cbU1sx)*@Y-StBjFNzMja@-sa<{yHzj7SS0Iih_kY5>Uz&FDGj!#m zb2a56v0?^ez2CFW!hP+#-RXGvB>BXS-jr$2xBp+-WKXAIeRH@D-||PY0JoGZU?0I5 zvCZU83^*e>wc%u8`Zv~BEX963k}RIhzEM{LzdU45SLn@(XQ|iQ*mtvu%dZ8K{v#zI6GvG{8 zuLle6J?ErTjyCu3L~II}Y9scqh9^?flSce=z@yZ|OX?+tH=&c9CiZ%ZHGx6tVdI;A zUS)m$4g1QE?D1=?XpSQ$?Je)OF^N*_;60AlCjURNj@Z7N0TwX;r(tpE5#+JTrQ>`!d=R1pTdWsF%?fVT!u|s&m|4&6QMhT2j0%K%mP&t7y(z~^iz!;g2 z7f9Yh-QQF`tG~-BT;ooE;oh#~yW#fXn%TJW0)u%L<|QM|LXulZ^?1t2LG>JT)!ANm zhdnVD$&9$ZFrNIpmTlLfU&p!^utsn%;)moLtdYKQopNYh@?DdYh&76~EmTc74t;EG zW+a96-3dL0;U4wH5kH!ly{TqE-li1HL{iICHn*Pa6(|2%EF;#izwUmFvBuaZ{S!O_ zgCze0D~#g#!yqLvNC^y*J6wZ#>=L<|=ti2g>Z}%~!#=X6OVD{_hWV!Q*g*|h6?VQ; zuBuZV_pshV`d5)BdOX3imEpc%51eJh>Ai}MbXJ#pkDMa=bPU_D8>V5b*xd;EIS`_5 zeAU@q<#{i0KW0h$%puKT8uTPe)$sbv1dq%_R&C<@KlItp`P|w4{DNIEkUuu&44=7+wH@HTp5SxzfKpF3 z6+SPMS7@o>(_b4uyhv`FyJYTV2<9$@8Dz;<;_uUa-dyC(9(Zu=Q7yBbdJBDN6ReUX z_Vzgu#5r}3nxE7f>pdNL<~j9`r^9w8UvGEL_mkCTF@-63c2##2#wfWi?G?A^EuL{d z7vRIe2GTQP*zVTdY_d(QK={Q*M9Bvaf+aBy;U-d^&AKNJwJ(2uxufbh&Jbscs8KFylru)ov;y1O_ z4i4(USaP>o;yNWbM|G#j3@5#vCWpo35h4bv2R=u?9^a9%04oU{rlu#ztrUFZ0-n8S zW8mSA61XGxw+eSyP2i5?Ib>wqHMk>og$ZbQV?q2fh7TWc(o6CkKFQ4&V561E4A>$w zw!|*T3fQ6qwy2Gxf-P##hCZ51dfizckJrpDBCGWd@_JY!`JG%JXYZ1#>iK_D-^7~Om zHNlJepWvGgwtzZ5H4>d-m7QWPUFuH9ss$a9%cHZL!-9A!>aorJH>^>6X4Pr#+V*0Y z)~b$SP%qdLTT5J-j5K?RjoBn;8_D^px+ectgAEhitA}DsPOMIkrOD&=FJg#xr@z<9 z)Eki9Ta%aFd0(6XriWBRj8AMUi^#l`|B#7IHuz9kv79)<6qk15rd{N31B`4#&B(`QyynSVOO)=0ye z^wWRc?-Q+SI{na>j}uQGQ5(pw5u-3Sl1|FVFMgr#gdb|pSA3k09Ob^6H8nZnjP%S4 zWXF1V>VCGKyqLPE0X=YAYDW9?=;$?4{TgmUvN^NGb2_3wsXFtMo|A5!m z^*p~);V)R@KRwGK{IuoZG*|Q-uqk@RRA4yGPpAK3Q^=A|GP@hEj%5d?<^lJrJ8Hmv z@Hg?=U(z&zQ&EH2NFokphJFZeCJB9{c?O-oDJ|A57+%2LzvM z#w?pG&WfFn&aV5MugK8Z-SaN;?l5ck3tl)$j_3$-X3%;La1Ot^`+vu~v3J+ArDpL( zNuP0_8*_T*{+M5-R@Y~*RM%wl+PLIws=pK6wj$`;qvNTH`E%U4ao5ld#@lbcWA{ zS8308eb(M~$r*j@bKzFxd4}W=;PS2G89cR^GdWp}&*k{=HoqSf6I#&ymG4&%%$9N2 zVlS&j>DEW_+gHx@C;RX>=lY8GpUNJ56JMS~f89l1EkQqRPX^BKx!_pf>g6|l4w(VJ zmC0>nYR4*YCqd8jP8i9l#UU)`ertdqNIoQ^t}N*RO5VTUF{$0t?3%Pc`N`+Oyd*F$ zbVR?t4SLvn-N~qz{eBJ^ei6D7-G%;(exQdIM2n&&QJkZ)5?T|*I;%aiSr@t~X8XwRV6&|ByO^eOr;`WgKyeh}w6Jd55y|3vSh56~y*zvvtM zxhRT!x;R<_Es2&Fd5Ana7ru@&k2V$GkjscQp)fb(kn@GvY0pV-*@v-Y#$oumk3F=D zI6=hpY>6&*t~WZHJLPpECgCl6+{1=m$R2-*moMO7+?5(dbA2e#7^^iE4Oa3LA73Tjl|n z&-=-pSKPrhW1J2D!}ugHK4u{237k&?=aazsz;u#v;$3}Y25e?AnmzLed3XwacB1zl zV$Co-@a|@a;L}-34OsF@vJHLzyZ8P=zW*Z5W?mv}cAq*_eR%NPpyxXnkG@1626QR< zi447!eY88?SMzQjZk1hHEjD0#JxKrV$^NRLebxN9SFr8PVnMoGt$cEf=YN4-X~_rh zZS-W2s}_?zSN>rKpSLS}VMm|0k9froY}rvrkG-}nw{Ya)jz)5QUWYkJW6U^QY5&b^ z3T8IR@90Ni9m7bxTR+!|m}BsqL4Kvs&qpsW&viAwHr{yIEmMg2 zH@U`UF~lY_OUfK%eJJebKIjK)`PQ8`mk|c5B;KdK+}Xr@XqP*PU3R!s<9k{9Q-43?H94h&;4A=2L$uiiYHr@cXNRC}iviy&FE`yT*QYXmoqPH;pQ++IF2+}@I_Kr^{gq^K#NCg{@??=T3;VH;o@C>g zCl%gv2Ifie8FDjs^I)D-Fi$E}{7t{Aa6B?kN*@n>L-}duNd@zyf_YM6ctyLWm^_s? ztf|wl>CIVFPcg*zBJ-Vt`fwPxLY%4>cEbF1Jn@e2`^-L?F{MZBpdJ`GyzX#2*7)$~ zY2;^(&dcf8lHOqEVe!SyoDvJHC-*vs!|?jg)_Q>2iG}$%amL81?7ds^e%1vXnRAW# zPJJuH)btX~)VX{84rJ$$yVq%du6F+}p{t^tc+CB~(_YQ$elJB(Vb{{9P)&GjF zrvLbf{OTb!1AO*UU(CNmyjw7*Dy+C7)xhNg}EJ+Tad>hSI=S>##!X%xF+yg z{1r0>-Tu}6jQ!Bx6YoBdY`@iWnO_xV&oi|F{Y57}`Wuaiz#kLp&tGnSkik@M}Bzt9(jub@vH8?&XZ18&ZcbmO%XZB*hyklK|kk`ApPj7jihI4E|!tVBtv3H{j3OE4Zsz?@-*A_p8InijsU#tYv$<)T@V* z?qFUAgO$Kw>C074$b&ZiCnD5gu-MF1_1`rzwPvnY7k{~jWPo0wuji$&m$LV_q1WB> z|HI3-IkOA!@uMi#2;GZ+FK~9d+2_63lzsN-S90VzpL+v6LY4-;E`I<9!F`T>0b&fy zj4ha*q41=8du`S)rrszHpu?{sGbW{G_Sw%YZH771w0OY!{t7SJgiqW{&LPgj`rKU@ z@fx$P{;l@PoaaJa-Sl>!GI*>69!ufox{GbY>)Os zr@Qxc&pQFXpM{#_HurgWCQKAV_!HTC8-9K- z?NRGG6_z%rQz-bTRr%s`-4ghPT{|PjHB3E!OX0X;^C|5 z)s^Y^e>wYkGBH@^I3KyMN|_%hcfbcS7fWomkiSufBFFX}p7&YoZFxkmGY?ChO=$NO zkNs$G95qu|(le;9^sHk2*1Zw=c@G(}ue&I34C~P6`}_4($mI3%pf<9&*B-{a#Vq9U zP2})4F&<4{o?(wi+n>mLo*n+CR7BtIDSJH=KI!zHeeDMn3wf;{n*F(*e!bAW_$OM? zzmFj6H?&V1+pi~lKFnOPmY+YP9RvipR4i1_Q40gc+X$G#~iC-TG~kt zP7z~lvhAB;&r$}z-!K?og>xtL67&pbkx}cCgCFy)XD3&VW!nt!vnIR0=5d9) z@{)cj(L*q+iTq!KZ8SxGAhXUU?4TY;Z0S-mRASG|Wt!Oq&!Jw4{x`Er{I;gvZG_$1 z(w|UV+a2h&XAe5tHLZOf`r-$%mL16;GrZ_3I6B|EP}&D)pQ@wLBcdb+g&r@pl8@MG zdx>fF=&t9h;5Cq`9|2~nY>y(9LRP#m7R3Ed-S9K zUYbq3IaxKqSv{RL^!jPS8tMN>ZZ9r6@j5yCy8SeZE11O<^gY(sUfzxV_!-E{Bq&Pkp{?5_-OP-)NdSx&t8OS0iFVl>A^{>Iz0;O*rQ>^@xYIqnvJ z+n!uRAMGXg_5qysShD9@`>&6h*qmM`UNeK>B7IESZLF`tC*)r_+*%l0Pr95oLNZWIpCKA8umXTDjV&I0yJ zydyI^pcKpo3$ux{!GZDJ*+u->!^o98MMfTxqnLvnFX6RZtO`FBYvXZvE;y8eO(sw3 zb)%f;PHfQq@z8zGW+ta=Lk3D^g z4JzBKB%w{JSx_(r3V@t0mRS94&%B zI`G5_POorFXB9qnPTDVJR^&m^1`r^^j7Q_X`WaxPt3Ze$}d#f z{i>_v?wn+8Rm@@)erFH;G^_iymUTSmS&s0m2htO9Ucds*VkiF{`;{-^{okXD$WuAV zVmEwzm;3uFK7Y#nfA6!lU7W{U&gMAlnw?x)+PUm*KVuHmY%zU?VDITSbH!i_DrTdbo6s=? zzo&N{epnBmo{IODB7?W1&tfgPnKs3GVjX5I6c2Yy(bH@o_ER>Wr(*5mWMm`nT}@lT z2d~0FRg3Eoe2rSPE_T&e`e($xH0kzKpOI$rpmiNc)*XdTB(wjOd7x^abQ^#-q6+WM2KgBb= zgWoUK6tRQ5lhDupNMBAo@ZOnetO4b|35%?=t&))*E8OO;NuVNGdk*6d+`oE z@jjXHB;G$oAE3$Z<-B-f8Mf;<&-4Ji$ErTRL2ljQE-WA}Vdj}0!t!Bc*ahTC#3@|K zMmWyCZsj|+a5j&T-{;eRFMHnO`PHZ4+wbLK%;qJpGkpbH?lD{@nHcMp>+Itz=;-sv zfPaxMe*`2NNP1=HssKcMM zignnIyV_qf&XV8KhSATks`zU)zUvue(i7y`pUCIYrGdes*iv?&tcBv0=_&voZf_G_F5p9gLs!74W1Vs&a*c4 z@`tPBi{9rupW^GT?0I5;=vnzC3tOWaM7}eO9hvwefBy}<6zeG?w%n|;U{;wvm4mS- zhFm&38qXZ!eDrV&k7s3bR)*CWH_D%ahi4xrFJ893 zSIO6_ea5|LlJhv5J!5WJSP~uV{;nq$MXsyqE%R?GZClr@GI6P?WMCs1$r{O}Vwn0P znY9;!`C`F*vB=|m{+6DrBT-%^tFo^Wzx#LIOkk{Nt^gBKwELMpCN_QvOzzrjT=|^h z4F2k~`GZXeSC#zc{``IPcvO+Vs8BXE_()cDuJES z$E%P(uG;5`WO^fcO8nufG!@gz?E)*7qc9z#u$n-TbIvZWsSmA28psradvUE11~@ zLvQv5iglM}b_FxLf|*^x%r3n!hs6)eu%~4?yFx9ZzEpVfL$+%#+hn|-OQILquo0vG zE?K#DmKG0@UC(>Q?dX)ne3zQmu!qky%PY$ISU1iGtcaQRoAsp+wY%~oyM7hCxu$!* zp7&0*C(-|$*rwJozL9J$+I^5xd$tF=;yCuiBlhhD z^o>|%YTr8L8B9Zv3(4d!&6#m0ZnWmj-HZ9``EGb=aMU!mL12ri(U)61(K=#}RamVA zRx26IhxvAC0;44c*DIGcB9@|_*WVV+>iSRfA?(-W(XC><`*k5X0QV%OmBFRbeR$K{ zGI`c2-O$Mf>4dfGOddr4Lkr>6+3*t#l)F%7d6W|vD0)i&BX=GKDuIFW-m1TtsSVEx z0|lc#mR~zU{xriwY}Qwt{ifErh5h=945(S}Vq{T<$4|y*>$1oG4}RcVXLLOtm_dde z#OM72-o!9?SsB$Y}1+Cuh{ciKihWC2J^G% z%0mC&A^l-G_2=jmqnarGoVt~4*t`{U17c6|c-DHM_3c7mSNJYwVzEsI#m{<^SWoe= zXA)0J;H46Hsbo2_ZU?r(A8eRw-Jd5$=?}_Z$nDiT_H3nG9?aQ276I15c9qf zlMv%jy>#{bVp?l>&nj%YhBb+0iLVZtCp~~4`t*TS-{X7B_5ijjSrWy$6tPzXY!z(F zfc+hSfz9Pq;qUDY>{NTU4D6Ix@kA@l*?Wg0mgUyV!NX?1=%j=DB*w65M7ffxAlJuAHs9eCG>y z#SSYHxGS@Xhmt#e|N88@`S_rJ#asKRLrh|<)xKVb*Y_yZ+2pDBie31gWzsx(FzXak z8>Wx-)nsq(l=q7DH;V)Kc2)d#s+GY#i3OJ7NLsK{_3)B?SUH0ykPldiUY|@;JWYn0 zr)5n+pU(kvV+O+0?6?~``qc9`i@Dj$5$_uNH~q=ky=jkLV5iSUMwIEh*Q|G0vf>4F ziU0nBZ#LPT*LzNkr$^3yDm)+FC^eFwOU>A4pIy?$_s_yL$ZW1)HkUYv%@E zsdjA`+?3PG;bhbZr9*l(*}7!z3HEB7KaBPI-fTe4Rf?C&!+6t93Vqqj=IY_4#lJA6MoRg5*5(FKQH7JsOUD^BNc zru_O${RuwH)O2`mGrH7^RKz_i!Hll3Jf1P53x;<{97_MyTu&do2(KkBR!iWu#ML^* zTe=c>Ex7uTWL`yVgB8&OYx+XPJ9p7L*xbn^4 z9i4q2x(QY2lr!>Np1=%VYrD=qEkOTnLI$7a^Op5l1^UVvt>CQI^_h$M%+-CS`as`Z zg&(VuT~+zsntYU=)9Cn7J#va;i_Osy{OlFcX8g!q$-(RJ$3paToEdTr`}QC@a1ZO& zzon>qj<uwVIV5erIbFSS%UJ>^rWajE zo?xf-dLJy9`9>wN?&)?*eYZ1;v%U^-p84`!a1L%jf!x zy6a}y$mw>%RZW9g(;tifyfNAoZHBf++o2=S3D$Qmzxq6MA-WAcfF40lqmR+o=znC~ zY-kQNCz>10hZaN2q2GnuyLr=c9`d{AO|sin+Uc_~((w9zai^|DdnYcj!kt z;Th6$VYD1tnV&v0nqBUHPJHzm8%_P9UaxW=WX=;}SLU7ZF9*Z2YR(pRckZ#jhm;1? zT=s?g$l<%$#%es+m3n_V^KaOkAMv41cfWUMtHs*X>*yMDzJfVl{0JB+eqzLd!IF>{ zd2*7yYM`s_*A)A4J-Qpcg5E=)pns!3tS{<=wb5p161p1QWz9EO-%Zx{xJi&}IH&u` z&$oTYckG=Za!%i*bgOXl+)*g88~)l;J;-#CnK z%-8ljufh*+Mvu*kUzg=)KJ6YY!e{7YFPugGZQ^-m6%T`tGewVTaCXv4i6m2wp*W1yt_LFI|j$4 zU#K<1j_EmHPGHBJD(t^=UcxzVFUoT`J6GM77+T6!&D4nIZ5-i)?)^Slvv}AZvndi- zGW8mjHXdL%xPa}Q!Oh}+u}I!9W6aQ#HurS z3^M*;GT!VjbwGMJdcGUkUGP&0{1nccDOrdte}jJ`2P5Y&$evC4(z#d+JA*G|J{at9 zHJA?;^!IGnE13@#%m<^h-2pb^%&A_c9pWYSd=sB@e>$K?H~ZRI#ackPDt#nMxC)LL z-GM(~suGwgu`sjKNw5dl75B6CCW)(FlGkH?4zE|??xw1z&&>N!tLJW;C8i(jB-o4$ z#-bHg$AfWZ*!%9e*@pqsx5c|-_xFg&Y ztD3#+dEzI-P05j~N%Kr_Q{q5Xb|rc0JmIHAchmr~an_+Lk3$K*xtb397k*xXZho2W zT*DsCVUI3@Y3%WwFK7LHpsd})^JLFBPvnypY_l#pvVe7( zNUv02Yy0(Y$&*XT`rAswu~$pDHidUD^~Rp?!HlwY&g3+Aa?iX^pWWVA2dvh+5#Gr& z@wL2o)_KJK91(~2BmZ+ld*9>dN@z#1?n~qwR!8fJZO#dgwkTR2ZHrX*uyw|&of;P(Ai=ww%EJq2X@eDso8tv%Z=HfSa8O6Dw$0biht3Q`#U-J(HUgHj5M}L zZZ@;|gK10t)oe!moThs7`&>PK+1r!V!8F6Axn2$8#_#z4*YMgK&S<56|GeJA@M=qX-5VXfa8F`lzH4r;`KLWw z5Fc%Ucj2(y(@Fw|rAMQBB76sf#jmQ0)mP>GVuiN*OmD2iE)hdf8=Av+l=M3(2ea7P z{WZ*DGY5M}zN^KKY9wo?eeP0K-P2h5egwXxku>qcH|_+?mAFE~?3AV+x*6#m9LYKOT+#OYWTKuFT;c4C15v=*)+lKm3#!rkhfUv@trpBy z6Km`X+v3YuUnTx-4gmazJDua36HCn`h_T!xjyxS#9YxPSOa`pPK8bObIr02r_Gulu z{0iUmgu4)J<#r>~Qnf*e}ES8|n*&r{1xaKk)ny)^G$~_YQHBnp|y-p6-PI z?-ZAu+~)r~?ZY~ylFuxQl~mQ3ROP3taL84?AxC1~2yQ$hcU#5hVs!K2gT?U2$$YS7 z*%;=j1@qM8I;#4wjF{&)l#CYtx^GlVuDO|f<+bor@R*s}q6U7h!_2u;&gn@!@VNas zi(UF6TXq?;#+);8Y;(2f!hx(AK8v!-9>YlSGuiNX3`WYn!%nyxFjD?|B>J>+xu!Jw zj?2l6_r*c3@f6UnFiQ!{QUbG-z$_&&OKycYjB{NYzrriUxe~>n-M2&81aCXLy0d!#?ay9();i#m z68I$fu2KSVTzgu(r|>fDo<-chZg=Bc z^8YD6moJsY^I;mv>eI>DUia%1GU&`KRj*%R;|_!)+~HH%&OLmMvOBqk`!n9zzvO4^ z{XF6x9GF-1T&d_~=svg;@1bANLS%Xi4WN6F^}w0y0TT1NWa;Df|8-Q*ck-Ql*5Ey% zSQ_nzjzQ+bwC73v&Ck2gBj_1%n7f=ATw*&HpR?umMDjs${II)?qO;Ld zbTN7oy@x(RpOZH$k~b@(t(ra26YjZ7 z?5PWmr%UXzOZ=rvACxY-p-Vkp7a7&1kH#3e)G=(rF=FoB?s~VH+ip6)o3Go=_U`fb z9(afzF~S}-Fg>29hm7nIm*^3@7|Y%qE5AHW%;g+5cb|Di4cK{lCL8cPS-U5qyaJ!H zERU`BguKhh{D@EPb??^5TKZ||3xk){!pIq#&4`C14sI{JH31KNKhca0 zcML90pM`1y6Q|aqsuyEbuANoDj(~|HXFAm*bjvr7By0LEwT|+818Nlq$YXLj?-SEw zi@T>s($U9w-YfY{X87r|I+2fRE*pY@OOE%PF$WGi$EGc}=O)3V)kVS)*pTkXP2XOiZ6on>?On`nc%_ zL^p0r9>Cb?DVTbeESyhgbcv6e?-w4SE0^?4%h>CS>F`+3uxARD@4K66P?G~wmo!3e zp0;~b???|H$EJgC)AynkXV%%17QcU3+@5?SSMs!F&Y;^==LcsQ-p8lnz3cltGwt-WRS%Iji;>(6^pqSWUmqhw5;&o?*v+yC zvDXE>YT<4c`XUYR?e!bRC+d0VFZ~ai8PP=KPlu zzBT{O+7o;iXBl0~KAnd>`lkKg-(Fps2EANs>Pc$q5o;mNc-)(Ha2Px64*a!Jhkx74 zg-iY7zicKv2?rPTEZ^8HP&VNg_;u|x6CX9h)7}46p6L|dw<})F-Jz{e2i^Awy>||q zIra^h;XGGhSKQ`Vp37SBM5W-anhR$JD;_l?Pmj7P`@5?Cx+ag=35U_eADklBVxBHN zuNSM?EYsi(_4VNs4a2xbe6jg?VMCuWx3l>>`@rlx{wqA8XOn}JhpO?XI>VyK{5&x! zb4K0mRq)5-^vP`G`@Q7%cs_iLSA9+v+~YN)@c0J4=NfCd-d&zZZjMF+=soh`N3vmN z@88|~r-`lb*x_gEaITrzb`3sV3X`wb9vcj{PA{u!thq(;;03jG||WN3_MP}ft;?f2JsmRac8jnHQ3A{1+O z8mNi-(Exf6{e-r(_G{?ZWjz1#sE*=ZjHNTzMweLA26W^oKL_Z(4eU>g4*Lr|wVSoZ zd6XOASGYj_VM{N_mL9vka3r#;;w>?*8|%e)NE>Fonthd4+Wqh0_mV@&;~}!Wil1Yi z_E$XILl!US-pz{EVnKDVO+_T+Ma4kL%>&(ulFxot-0mte;v{{CYwX58wr#|C!uP?# ztM4T9WtS89K5^jzIrqAJdQ1FHF5S7_?mb6~^Htbvn|RKM|KVhto6;NpO@3YM-`C^i zFT?|2b&AW={&sHZ6#0%Vor&B8JokwG=yRvkC%T(cblx?KRli_HQA%RWSDvOYF@^8?^)jSn^?ISgJBl9K=!|!D2z3~WNtF) zOn3MPJa4`r3{+W7k{ME7dpR9xwqSS{eM>f(Ef|)=XK%^b#yIcg2=+D3EUeyN1YM+yED1To%z~lb~}#?(F5+r2JXrAKKoZak@g}_5A-Z& zlQ$Rpxj!D9=Iobur|)(CU*o4LTYhEo?8!7wwj$$SO#4FYaleMonul&!13z3WCws+c zc~rjORV8zt@$UU(?$Yky{ba?`)(NvlZ>m?t>u_rc+!~9lPyVO`f2?nIDOXoo7Do^- z^uGDs%h}QK?%sI!Z8!Hzm-UE^Rp)GWajL&5*=Po$Gt|$M9zD{tUrP23`?>BPU$2Aje$4vy5}Qum!Fl7Q{hZ?s_S9^|HlAyDHp7P|#?e_`RAdXagYL6z6IWME{JBGz)GjgrW z-W!zjtdlwB^Z0)A55p4v25%=P)gS8=+gRJj>8d#Md{ewR)X|FaHcVh63?liZU^Ze{ zp1rZY+_v6NYV6Gkw6?{>DYofo@rT5Rd>>3*ax)u)&l9W*Vwpgt2mOC&EIUi4S|66U-d{ zUEe(GT?|isNnYwtYUXLG#sg-`=WgOVpR{j!&ZsqQB%^%iF7(jVXhwW?_vt%#;NNVV zQ+@ARa^JB=N!2rIwfhwOkm+Y7_Hj%)pbo39*JU%@%{Jab3~D!YC^`w9k1j*8hJ6g% zcxLkQ7VFVV+9cA6Ol0`2#5BNKnu@b!gWPN1o;=HLGxEVRftitdR zKi;guU{)dQB5aa4lv#zrtin(xJN}RCFso24bEh5v=Q#Uja(bze9Fk6QCnmutH^a=O z6t1`wK7ea7d(iAUSYYqlA5OsRLAl?&jZrsyP;6i_83H4L*BWFpjGnwE-^EWDy#z*& zo+_)g3UJ2*Q7@?(&DElog4u(iLXMg}=!`1iQFm@nGVdv}ZY#FKXP(#WLD;=PwM;cS zsu|25grjP~E2Qiw{k!Ol#mJ5cY~Z==7kqZxUO1ZVv$OsAi40oPy`D(FyyV|Y=iTCI zQ(+$h9Fw`r>~2`Sb}tb)y#!8AJt2PajOGifj~#5|+ehJ#|CXA?XRxA+P(a(Rfncr0%ghq(u_Pa^!D zxV}6R-B6*|$L8|W&i7FK`UIQIEWxm#?|V_qZ&A+;S0TQqe+ge;OK}&*INuil-OR4}z+K%qK$g`hMhMwatm{}Oi zEQI@>BDbU0WY!y=$FFa)4`2k<>(ZNP*~|wsI_WwXK{C^9Hv9`Ch+p+(aYtYTVexC? ziJfvvo#F5t>d=bbv>hUEL*IkgCRaVkE$s|1fl7Q9WD-I$rBfVZEK zN1E>bn|Y|F5+2D~%sh0S<03B9{q1Ed$rIt7XT&nhJq)ySfQ=3Zk+B=mk>(znH^okL z-Y|~NjE_v-!#L`7P?6^y;T z^!XU&zW&u+-3}e9HhedC^(gVKz1-KMJlkFB&dqY*N9E#|@T%^|HApWfb7S;yORHv2 z>0j(jerD&*K^|QwKk<#bIS1Zf!yYfk?|KU#v0Z}siF&pTs+r4@8Tc8F(d)~}F8H@H zswY{9udxDOV=mFH4jLoj2TVDv z&$_;D)^?_6*pEF3!v|xYi#L{Fn@a7TiVN}Cy8S(qk8#qI68-nSrm`-Ss@KNTm`_nEFZfAmcH zn@zK?Y7}77%bp!J(H_ySVj9z&$EJ8)O@n&ZiS|k#PWx`|BD)iwbksDx5XB1Fn6Qk+ zfzBw_QNM3Z%lO_m$i4a5Fb}XP9~aNcea?ey?Y+oXn8pOAF=_WNAmirpzWrg7BKGf= zv_Iw{_$|$1;}RS^x$yv+Zm3y;J-(=6zx8)ZEH{xFfLQuoxBCxk_>)x&yt9 z-a-E&yXHkpq1eazICLsH3r$Doq8riQ#B1~~g5T{DhwYMQ>|*bCC7<(N-$HMr&-n!x zy2I~_Yu!i&UV(1+`_1v%eD=K->vF~Zf;H@AJ;&k~H4A1_R$yM$y*Pto)tIh3s+mOm z<&qtJ;2?djg^!+}%}Z}N0+Jai0wwL{us zE9kYrz8~eD9%-M~$G30AyoqP%@;*7|VqbC3D8DA51Dwf2Ui%G-KJU@&{D41?MQ~3Xvo*gV%epZDl7^CE+oTGC%C%vv9A$NxUd zn#ty5$Xw*c_vr8V`y6?!Z}9a=@`G`P(8bQRhThfX2 z=_FXoXfqbm#l%@LbV2I%8P6``BV>9Y=j^mxZn2cWT=MTr3Cv{zbE!sB9gfe0xs)3V zVzhzmEZ9wjyKlaq^MbjA0j-j!>gwoBm`n1u#@Fl=SMPDMWAV(`1nyD~v~j*;#OsG* z?UT9aee$&Z{D}-E)LO0AOiVbEGG9hK4Vj4<%)~U8n0TQR%)}J$sD=aRw11GFW@5V2 zUCv=lyEg!AUsAUgxJ@xe{S(*l&Ku5+8%#{^OWNauyQH8 ztwBEahN%10B_`?;^}@|zU53n_R?p-9y>DH!p_j$Sjubbp;48Kmyg3=}ysyXWpP+5> zzBZnJ5}kNC|MfvOSIM3FpYt4IpN-J*yV$dH@YasL8{Q|@N)?}?-?Dx=z6Slv-|?CJ z-Q*B!IfU-?1UvXSGIy$q1P5g$vSc3vL)hCWAXj+UjMxBecHKfl%`>J{>Wpm{UnFxDV(yJZ?^)$=Gf>xaEo71LYYdBBj!Jq++&Q@&IN1FyfK zI}gK}z_2C{XT9dH)%7e*;A#z4yBxz3R{P?dChftLkyoOy0=) z)g9z?Rx7+ule|H1#2M60Hq#AcDm*uxQV9#=>6Y(Xo!&l@f3~Ao)Jo33lik=s=B#S% z_wrSv9$mpRU#GrvVX?gH#o*rcJQwg^PRg3$QFh6mr(zk=1w-m z*qdherR^N#TJHF{&ggCT@PDY&XUDvI#1p=b-bWv@^VF-sTm*gV3ceJ70gb`er=aLR z{146IZwsPj&>83gbPL*oJ$4DY9NoYkn}i3~i*f_;DfnNo7by02-4z{(j>e;FyDw*> ztI?O}NHLTP&~4~3^c;H2x>s?hRz(9yhg5z>r{02{#T0p<+4&z^A@ktwsFUPU>BHcsdsuy%%YJb ze2J2N9~?2gzPA|PxYMReA>7K?lXb=#QD?wD^+s{drelreZnYLjK{O{3o*QR&zh5@RR1Y{%!H%3hdxx{BD~6K9p=d*S~k=Bloz& zhq0OG_L@8F^@sT6J+gj0KjtH`rbWq+`%*QCUUxnD@hQ9YchB@0S$`jT75yNd@PT*& z-vc(g+nq?|GW50bp1tyBa*H*-%&uFC?7kAuo5d*(QVNT+GycPFGmA5r#VJlY5EgfL z)%oLHxJ1u?le7C8O>nOsquZ9k*Ry)QPuvf4I>jl27>bz@?$96X>P0&#@GjLI@{|{TYGmN*>OkI;bhiyyb$Gm2U}xH zXWW4wJLkU9fEuINZL!#4h;K=RWJb@`~zW%VMka9KKr%;Y;|$5X{wN z4;OI4)i52Ip$Y3V%$|Xbx1Tq$E9UpUarm01AW7j327elC~bU{ULWvKWjd@H=Xyn`R!FgJjQNVgriH(vbz*aZrq`rEiox3f|bz^RDHy&2Q!BH;bvMdLQ3? zM4AElr7?3W&eJ7H! ztLo)31z(>ssu?aQjj-o~dtvsv=ikxYiuTM|_`n=avmq@WPN zgXp3=(gE>`R9v^g_Sd(79FPx#G3)2Uvp?BwhuC|wHTjK=@HG7pF=^3uKRqjn$+U{~ zoR^uFA+q4e-LP?? zU9-K9{T#4I^ULGL7!dp$UqJsdx)=Vf-RDEBlHaHvkSu!0Ih$)qZuYn5C2lynWj0;I z9cvbwdWL76eUl80e!SU}!R$%CaWM0_Gi<5XgueD{)!yU;uNm^156FU5&>mj1k~Nt< z8O)y4AFCF=BAcUpeT?qCJ!=;0=B>~r<`HYvUZ!upqdWc}XE#HCaV9(C>wE0MD}KI+ zzxVT8S;^dwoUMX?VCUrYI$?3TNlCeGck&TyeLijJD;^R!x`e+fw=}@#faO7FIP()c z=S}Wqtfz%XQyZc;md{hGOQ)*cC$|p9&%fmISK=P~+vopt|8~YdAC~&etIvFAuFq4+ z3>6Wk61=4E=|tWa=|xos&odX>H0Dep5wy`?@bmv>NWllQZI^+hf9i>IkO z@*P*8g`MNop5q2o;UkRkJ@9H`Z!j_LF}#|275$z!C&IQoHP zl^j=LhMc;GK{MFR8zv`U+!DAhwoIp9G+nYCUC9CNz((XRjGG=3860MoT!V+<+sr`? z349y8Um<2(70s)uk?UkBkF{6L;)$FLVUKL(&TLO7%q*^aD4lE;La_I8tm^SHmNkNH zqyNqHMzC#g_hmH}l?1lUS%n0)ErD%IVB6aB2VmRu>QKLkVB6X~t79!RT$}i(T4$8t zvsjM=*QOq)>RI(GMlfx#wC2f(rNXqa{cADf*j_t48ym-5c^^PVn0yI3aO@Mk?@ zZBx~$wc;#4eOohetemVUn?Y!vmh)c8I(B8Jil>?bAJkk2`2cf5-K*nJzcnrDzuATD z+|$N+Km1`Sh;N6{VpAuL5;-B`E^uDw#ZU~L5NB4Z(@=AhwPW!g+skk9%>K?Zx5uyH z12cxnscy2fhaB$VpZ0kDSic{~J{m_Kk0Tq$v5Cg(uQwB0cqSh{Q{lA4)Zvdyy=Jwg z`fsG-na$##c_Vo@OZ7$0_=mYZbmmm^>&^Ux{Yu44&EzaKVV;NRhq^k?KK5fS?>S(O zamqIDPrkr^N8y7Q3)$EmgO4Mh^b;g!*CUhUPxN7&D1V)aJp^&DpeDR3hhK%OufkMY z8~T&qtqrsD9llw?vz0yPD)`b&Q2xOH+><+NpEn;h&RM0wTu^o?dCI2PzEmXF`ET<< z;WT>TVa&D2^=RRvKgJ%OmEE%u8>%92@*CavCO>jx|GvgO{Mz^K?VjDNMr{>(@G$58 zv~}Dl&b_Sfgj19A40@dMH}PQXpA4s_uSvb#qu^2Y%nNk?Hr~T-gugIn27kb#CGcpl zxoZ6JGd!A^F8%FU<}ojJJYHA;FTkL+dqPDF+NvGHZ66Hg%uK8S@v6Gn!wvPKDV>(Z zxl`m&scknuE~nfpzST#@jq|%%k=pQr&#C9I{&MWGZ{7XXt?vx-?AN{oSu&@b zR6X8apS?kv!Ml{gBKDF$V~%j09BCvg@W-dnUFL?idxgB@^~aHOW%&TuHL>U-fnDQ^ zn`iHi!LG^Mi-_2pn)lu6>|VhWFl@;MsoE7eqILZ@+?qI{z8R%l-lmUkACv4yb{~U| z=l7mW$9?TRJF;_PZY25#&+~isXMd;}Enc;zMZ{!|;sF+Yxc`H7s8a4jxk6RR(mpUVkzB4ODQST_E8VOH-j zU89c;TU5=ay!xPCG7a*(A2zCJ_hHa~n(paI7HLbw20pE;?c;O%JXkjUm_%ATYG(Be z!vm&lzfv%NRIluQ^-oQHu=#R$@+a>(1m0s6e$@Z5E6p2Kv#8dNZ}Yoz{+X|EFTHXs zKG*|Ayxh6`LbKu8aiZVE4X5(;=J49N*s|}5v%SN9Fn3fRq2qNJ)$a#*>XVL4NoRagIdHY(sn$@kTrO+flyjFmZ-OoxwJEs>N=z zKk@{nFmKwgZ(J|iA=PWRsrO4utZPu8rh-4FR~b5wJTNnqzf{26RzuECiM@Tz3{}rD z1~zcAoKf2D?Z3YB`NDeFAe;V<*DoV?7RFOC)&gh8X0O1w7v`)@#WQ)*m%>qH{dyhd z@KGf*7n|YUR8J<)EeGC?o&DK!?}p^Siuu{U+gU^EejMTcAL(u!#2(#@jNKfrd3I|% zJgLhg)zw(li+}o_*uP|D^bC9H+GsC&|J~>qcWZz7$z`3(KhToyAd8}nyML3s+YA5d zan_c(i{kC)-GiOTv?Ix@)$t^(AN)bn{HHuw*!PVgn}+%IdwU(MAO8zp!PzcNX3WF} zg7u3%LEC*P;QUCemc9*g>h8jg_I{6CZkQZg-5t{BiGR>EXRK5#>bd&u$M)pIw)W&9 zcE>Sng9GrKJExW+WxMqzFOVsF;J5k6aj`tLk-3<(es+j17V976Gc*!82E82hZD;fR zhs=IEZHnXRQ)oRg)^{fzAMyBRbFy9KgwR#a-)zn>kNwy;Zx(B2@(s?*TuyZp19(4I z$CuOp`XrDyPmz65wgqXkVc&hS^BQH(_39T}>{LtEZLg=u=`!AxBE@)h}Tb~H#VfJ-X;UKN%f!i47>Pg&Sx;=)BML$Fyj-BHt_8O zeHcO$-*zE0KFwaJhHf#dr9GQCx0x&Y^`MR2mwoY=UZnETRXV!n?sVd>$?#(8qsWe( z*{RVQ*;Q=CEKoiE)sG-KZF+4u?19hE$@#pVJbDo9zFN3**d=N!ob~&9 z3rG8UDfe_1I6HGk)m+P+`rTvr^)T{o9XviOKWH>L*%G^&m7IFLl+jn}ovpKBedF-! zo#g$iCB0_w{4#j+F8d#QACGb0Q#x=)QhzgC0gNSnJQ$x1zPh+*+Kw zbGZAzh_yuw;m6jqp0%B)kKLi3eU#7NicBm=e&!FrA&N5xzHDgsrG`UPr(L+Wv7)G& z_zX5~&Ashx>q9t1k>wtBr9I@-RJA#o7;V{pR^(pPji7&!5i5{MOM2em`Ihl~r=vm7 zv$}oX&@)90$6|v7n+f3?s$;rD$D_! zDkh*`ExudOzNzUeUe8*5@m!rrshERo_{}qI=6Ob;Gtmcl<#?oSL2gY=r{}xR9zO3` zU-z7AddAcqenvms=AN6s%D2^lrlX~{M=u(F#3Ifx%IAgr+&=Tv_@9qD#}&}_ zXfHI3u7mTrmVaPA8?0Opd}@zczaF`%9yNOBiY*Q5>n!F?1}>hf>!Y7wFB7?qMlF*1zpt(w`cgVjY+9L2g1Xpnsyb(02&d+Kk64+$=oOc3D>!pT0{kmmc-yJ#5sTkafi+BE4f(73K(Vjj4CN?8dp;+`R{lW>OZ8B=hE37nxg!4$cX zM)7CoFjg!j_dYm7d7L^sqE#%B;ParnrRuNzMY!CV?5$>&0AZe}@;eGiGVA4Lb4U4djX0spjO0k&z)g zAhT2XuKJUEray}}o1Lm|Nj;a(`z~wH7y3qez1gYZ2><>U-Y`3rj%1_Y3%Ek-&%_<| zvbUG-`VCy6enDn>IUBgbMBP#XGsvInR}b72n^UVwiuTY0>-yV{?3!cbR$vA7FVF{& zP5pq__2cdcTse$sS$$d`doxux(ku6wiv`u?hRXVZmGO2noS9|toN9i2=hN2Tg)44x zKQ|V;Qyb%ZVYhtOEop$MsTVgpQ&>Vh+$v&A;#mHt?+0J3CcfU8bjTa*U>8TB@n`~G z>Ow1_RnY0^e7rT*9!H;hrmO`s(jZ&2wvDm5eR{&aE=4Y##s}Em8EoS&ZNMK|L>wj7 zIKc#p@#Ofk)bUr!NcGrs7yCWm`uOP~zV`0+^)v5*Csb2cO5h3g z-zxj$vRa)=0#7JkVrIL4!xQSiU|lHot%E1jQ@h#j6R5T)h;PX+mcm9ktcJZaA69Hr zk7sh_?6hGvxIP}4dO~slZjcXNrGtmmQK%ae>o}R5kt-$s#owIU%xsDc(q?fVAM;qU`(*aO&7R3TSvs}M#|q|n z6#U&Hm?tZ~P&4ao7_I}J)b~dj_OkV~e9oTu^#|KsUB-rU<)V7OUUuiU-OA= zoZ&mok%cEN!EKeyyAR=UdAsfDJ=i<;ZA%Y)GX?D*>>cdiWT$FQy;zADgW81@52rA| zX3Mz;-R{P6zH>|beug{pP2PYv=!^KKFqKU?H@o!(KGtgZu{|Hwy1$kGginH3tk4B! zG$S}TaeP&1^0BMA6JO!=3-H2M?C%TAWSU)^Dgi7#7;x(U!wxlM^vVw!MCHWceuS3(32a*Z>FHi+9M{ zG1j8*2>((2BU$x1y=W$^I7XEW?Noo=?H-Kfe@qK2;?;-^yN2zssx$eS-B6}`{_ITu z!AJYlp2ZyT{d#HdPNvTw+toXYOu%cBTMKmzM4k>0<}EgM3MbbS%#aOc$g;V{i{s4< zJ9#c#NHdw9^~w`va5Q?oplQ}OGajAa=X@ZBRrCF~pxe;);v*lZA+3>v``V}IM=rz` zAVu}TP(O`t?m`E#Yd3RV|3Z(-`QJt-#u(2m_;mp>t&82a>)i?ZnT?~rf7+{7rKwhM z&`I^v@6F;I_hldZ52HqIRm4Wsn7Vf`YVCO|Gsvn=d;+J|j(xzX#lG`uMay~(>MtI7 z&QJKXB*y#M&X+@8c$+hO0`nIA zQL}8yW-*Gt;#;{4`Kw`fHiMVQ;1Bp|o@E~~jEJpX&)%twk!P)%lhMiFA6DzBe$x5D z$T{`0csU%!=!tY|&W|>aL5#*6UHO+Rn4=ra(GAOx1;fbv+;9e-H$PXdMbB~1Z+@=a zZm+t~79G^DKE9;Z$DAp?+w5ov{evD`Ox)^KGH7%5^aRgy7Mpra^7jY#yvKLL+tD>O zdo0_|Zdu&#evy~@g)h|2#)PvIS183EzR5=EOyVOm#ohtML0O@HY*F;1UUs{=w8dvW zKjM8Z;$QqgCmiccWd`kSKi^zUQrZ{dOr&eXt$%XIs$zulslgmwHbcMOTPdGY|1-AC zeDo_kp1RQrJWXiN(tyW<^MPgdyvNgIC(~bL_r+{lI4}Ll?b-8ehF{TP&K~AWt!+zv zN2Uf`UYdV0US9qu=lnOk0&52YUDw0M9A9$hV%V_Vednp-AQ$56`^c3FdqC}-J?&+e znx*7BV^1b{Iyv$tTv1DJ6aB)(HO-XOHz*5c$_Ddf!=ZU2e4l4#>}4>~&EkcuUfk~) z7It@jW5dGO>3!0lEWyq{adchpQN8V*+eh@pAJ%h-=Qn3oeNi6n_g%BNgTK<1@Q(a) zxia(szPrJ_-OIh*kGy$--}#9%-WI=@M;q9?da0CQkjt=RW%a{)+ta6Nx#hzO*peze zS`%xmvB5g6TIV!*3;ktq!Wg?U&MDT_!K8ZWG>Zm1dj+qJH3tiNMl)!G8MN>UBYel2 z+T5;W9}?h98hKs(4hKk*>=h?Iwdp*yr-ies6AUFgMm2lDnQM_V3fZ3PMdgmd_a!klcV4v1oV|IkVO{seyjS(0 z{d7pb`O7JceiqDl4eES?8Lu!GYKQS;2i;wap5_ke2TwMBg~z`k!{bbqCNQn8r8Ti$lSGkAD za?NT9?8)T37w#_AN2yf2=s9A}^e3|S&mEK1W0vJ_rtsIzK`p^zlv?^vHj;Vhrv2z7 zGhg++?N*~dHLUEkc0)hduY;Xs?7FouTE#go$)=pejfZAq;f(d~v5B0Hzl`&*ar)Jd zmxCMc_tTO^eHXl90lLfxFXusg ziVtcH{0e#Rn%+z`7#uRtYa=FR33k+c^nIMoeKwo;mAqaI;Qf91r4d_r>8NvJJ&?Il znff|5iF;tatonX)t;lclWy6Ma$4>atjMC;;5a?;tC$5l&d&!X#=-R@1x}ANe=e(ZXHm`L|6r=pB+(Z-4Z0a=&v9Gpuf8hA^ zDeTpwB*fN%=C>tpq8&C9-TQ+(Y*uT# z7m^vRe8ixh7dF6inBCfr#hgTDMm_K;J+qB7hvCyFrt!FRa zc^jQPujh>OS3dTPFnjHOzBlHBM@0-Iz4TevP} z0IMkGP~#hy`1Y+}<}8e%m;|{$pWnkIiX(K2Vf2P>@^UMmdmnm=o%Ej1HfNUHO53$S z%i?A8X4z3Gec!8ZoBlKSeVL9ic&po|bkk!!$tG;IXji}(>S1U86gdK8sOQf>vY9o^ zVhv`_1~X^X6X}IsQjd&ILv_CK6Jkjpp`YmaKclVCPH0zjJi1bUi5b4(Q!$gTNwSmZ zirK|H7I6PJr=LDf1G$n0Hg4EG)q^@K>7iN<r8hD5|cH-z z&JUk}YjqKP^9Jg7ROd!sA^J8!TWiN;Zp(tPTf?5jG4Wy@;qa?+_{~<-Q-8p<^d_#& zGY~`6uTLbj8&M~G7RU2hd^22$-)@HESczx1QMeY5!+E`pck)f}J85|SGw{ChRovhA zQBO+^;!>XgTZ{6XZcIWgu*sKC2;f!sm7<0*iz zPDPtjJNh(6-4gW(v`Z43@a%M<`NK5wHgQWvp@@k_%@9H(NO|2wGLqn|Y7%;zD8%E0>r-X{F?F=!g#dUD0#p#Gu5Z=ueA z2G__cT%+3KoW|ifX9%u+tr0I1aKAxrAM$9NxED>umgR<1A32@S#%eJ94>^7q;}U(} zV_om!9`X-E$MnOoTa9{tA$$=zf#N&F z&m#E3r-+Bw5PhE^4>=j@nuOmUgzuNgwZ?Zhd`riD(2L(3kNX?OWySmK8Mw!xPbK(n z0j_lz;}kjXq4VWSjVf|5eZh>Vn9x3V@5qL*mK-Ukn*UJ;Rs0W@xo5;@*n%x=N6 ziwC}h96hw5#F(?V1|dfe`8**4IeG#)dU(%^UqiI6!$i4W)XzEc^zi*Q965pbt^l7$ zo}NIS9{L!oC6K3wcD+$x6rRrKqKt7lNqc-o^9(cx>Y>BVX)r;5i%jE9BRSVc4e8IJOvTG%ObP zjRo-Ex!9+Hn&?(}xN&&>T%^2o#zb8h;H?xk19@_y+uS3K!#gAOj%}pQA%Q}cqd6-! zpOz8$X@N_Ez-1WuADHka6q}5$5Jb02&|j}zX~HVh-g-c!KQH~0JVz%6#cG3?ot5bz z;?L>DKUhALh~>hF*%d1h9=v=6(Ve}Z77@BgVlcT|6cK;5z4#|Mv%jQR%`6JmFteAx zT!+dFf1AzpW*(Ea+Z9do(?mZe*2{Ez_cFbjy)Kn|f9t|5{Bk%mxV%u(b&!cg>d|tA znXQ@F4rWn$uC&E!rWk!p&JWfwv%QbkCmptr>5d!D#C9@^#%*L`dzon~s${v_)qr&F zOC6cmekP6!6Z^sR&RWaF{>b@*%jJB{-jMV~P25cEAJcvQ4JP(e@^C&A`^)s!-7Ia_ zL8jY(nTelr(eD+OHIU3~%?z&WE;+M5Q#AXSiQ~fb_M0!u#cF2SpkgMD6Ei!xf{F7e z?RIq<(Ry&)nBM4)(q8^D6aK@*ab%{2Wy|@$&6ak@@0mEROfhFW6UUcX7+=Q3ah7}- z62trDb}_w;S~79mr9HU^6UU#Kotz<=mB|!Yxsu6qm|lH}j~4{MuSi>xw74jJEM|Qh9%(S8yX?q`Migm4-@H<&P*elDIzswAt{udK|$P|r+FyW7q zkBwr&FPTNmUsM~nSK5zCj3>FNBz!(-!i>n`y?}u$@xdlGU3O}w2y8` zuBejpk6Y4y7!phSSy;EWq}#>Jj&n2N=S;V~o#dsCvfOXV^2t4<{caEP|W+hC- zkDTB4h_v55%?u8`Amj@WO;HoCgPA;l>QnM@yPV143zetgP6f~?=cadvi#a-a=v%8oIhiN_%`r@(h^AuO7(fQ1DtEMP@p!U7f+u&{uI z1uQIJVF3#ZSXjWq0u~mquz-aHFlm@h z2lg)9>IzCF^ZU zZ&P}k(%Y2Yrt~(Y$HO@54W&1f9_cT<{YVp5l-p0k0MULJN^e(se4gX=BW*}g>gf@O zj)PsT->&p_=rwFNeM*&#KmtA4k&4kmgU$iHWURpRDeQPfsdp;96YD2Eh8|FqdK!*^ z^pqA(dZ*GmY5VyyMe$3QDvDoA#XnuP$bX6CzeMt1BKa?o{NKW%mwI*~=wvboxDA#=iwWkn5N6PqtjYjDNDFUdF#gyU2PO|CWk>qFld>f3oHF z+mv3$zeR_J^)mh~x}=f~O1+GKvZbB|cA)*2@sCfPN-yKzqSr&Lm+?=w+jjVaGoiCi4?y?ieDndFH!1c{9AZUNb!$m9vuG`&a>3Z_$OQHW&D$k z?bql$lK&IQe~IM3MDkxE`7e?DpBS$Q|A9`%KT+ys{F5#9GXBYydKv#@OTCPLI-gQ6 zSg?sE%h?~ z$(DK<|8#z(UdBJ!QZM75Y^j&=Pd3Fbokxm)BE>I};+IJAOQiTEQv4Dr{)tjAe^+=UG@gMWBV(T@*W+6j4Nq3?g1W zG0D@(miic_kHK8b*Qq00Dvwe67^TMtIyGPFsq=Zf?!!w$y5d+`97;hw4*!BSO1_q) zJ2KhmfPzU8Mz+)^D1Cy`C!mzdsRK(%sYfD=vZbDqi|kl`67-;!1U;xHVJXm-gnuRJ zN-F$1@H zvh#4OCzjw=&*ivPGjXYA8p6edBhqzT>NO$tn$l}Zk8;+7tOr>SvR+quUFmhD*OeaS ztOr>SvL0l;P3dh)PaT8M_S=*m<*Wx;53(L)y`l7m(xYhx>(NCw??1{}53(L)J;-{y z(o?z}9Y1ud&U(Ajqn!01>p|9oP7TM;0lj1f9sA>|T2iFf!%fa;n)N^qC0Bt$AYDiKI zglsfWVN#8PY^0_@Ukp8{6+;i|#n6McV(2BQ=0Y~5;S#APLZnV9EesGzH9B1XP=f>Y zB-F$}TM}wil2qd%8$(bssRlzfIwmH)t`oH+ooaN@H>gH{a)a*dM7l#0Llo(bOLizC4tgimT%dPS4Fq~8)g(~vq#6N{ z?(9Swh?q!sY9a>WB)yAjJkYzS<^sKoY9J_gQB8tKH3A|M(wTIJC!0EMfj&hiYDpNcz& z%NsVVA7p)u(#K%^q>oYh7^O!!>p|9otOuP2)*lDGWCl74COc0USbrS!2G);qp|9oPCM401ifSi8Xl0Hht5TaCBlyNqg=CN z{UAO8G7US{51aMrN}rDPlRjPP)0H0OtOr>SvL19gaR14HH%msKb1kw_V`HM`h5JVi z?jMq|!h!oo4(=b4i5Mi5;utkUCekgSD~4VYH8$vrp_fEcMd*v6mrO+BEA|65Pss>$ zh(vazVl*0ula1l@n6bi1_dhLO5#3Lb9yL};e5NKnYM_#+A(BpSpop|9((CbxiD*~> z8_713_-ILb12q~ZY9^#d!mwnl2qV1_ub7CATwpu#sgsH3Fr;&$Cd5Pn3hA8~T$&k+ zWMQ)76_HX&Iu|w2BBC=%(z#HBVxlHQI#&b5SP@BjSG-~(64+p;piw?E0*xQYj#P|B zV|}t4D8{05Dzf7h6NLl*mjnNi%n%OvPY(RY0sqT^|2W`(DAyeDKM*OrOv3^HgY67~ zz8HGR3?vhhorgiUi6tTgdX#G+(1S?xVHzRO!*)8!|1}>vP9SCoC;2}<@H)x=wG!bZ z|JQt)ll)&p_tWJ6n$K{O|7$*HDCu+`2H_xPh)~k&c_NhbdWi@nz3$UONw52mQouAq zNw53Rqd#c)FsLsv0|S2(^F$cwjS>+?dc&uMk>2njb%TkFC8jfibWWd;%n%Wzcjk!* z(mP8;1nHd^E`jt;AJVp%Mg-}dK4&E9T|Ob1AtFid%0t5=Vu^?(z00RXlHTP*nk>_Z zB)!Y$bdf&ACnPh_F)Z16!bSR&65%3!icfQqKE}T%=F&IW0W;$76a6AF^p0 zjcGTg_y6BK4Cx?Vz;qC=3r1jShl!Sr#8?n2HIZC*HyQS26KlwztS#m=>%(tM`F+Ye!T%C%^P(%N6fkc72_4qSLRR z-#2n!*!K9+!58bzed9=nji23#nBH^G(<_HvZL;XCQjdSkKYC75aom#h3(;Tx>rle_ zPi}=xeP!2^|M{RIX2F0{UAFwY+L7lgiC>m+slosBJ(l=$*1gDr*Y>qpJ^Xs?x9^;N ze(ShL+JtU@H2ZGQ`8u;-KlseLkvBu9yu7p3kMEZ^n&1Cq=gnU{uupn%`x8G5`MdtS zH;+EMDf4cv8NK$lUiHzn$G&;{OxNGX*4QR?|8Mi}-~FrZoIZ!!Z}{|f__SAdKlRgx zR~j!Ic>1~DMn4S6@3EuB@}Xr7zv_3q<1eGCqGl%VZ@cE>8%-Cdo-+gE@kzivq(}WK zQ!KgB<{x`m*Ul54f?XEaYIG?L-Er1@*mlI=9`%n0Ug~M7l zc>am>UFM@4xqOvPE^m$@`*`5uz)D{J@0nR=La}^e*|ylMLA%U_%Ln_-`a1%zG_HK( zVD2{4)9LBu7pD{lGOiD3*>*#bd4J`)4_iKt?OD6`dTQwTz;}BNWmKKNXNm(^zt7DL z2Bscq7uoeY*!M55?ydy`lZG8gxH<^7H#~9sqqBkgU)Pye-5hrCmza|^X9C0Y{YwXy z-8IFm9TBUo(!j6D%?8+4!Y-_-)5$0e#13x|b!{Z+B!Qo*mg?%?-EuI<(CMBsXI`;DFF!4CfTU`n^+f%lKD zIk!8F${THZ>dj+;KASJTmeCq^?S)I4e|R*o?8IYrw1>B`{?w=;6ORNEQzCwux0CF9 z9m~Ht9C)SX=U1A{hn+T~&v#o61vbqOMijgc+q=s<@#Mk4`m(w?7rVd?db>=jJ`h;< z`=myVYQb(-mayot1A*fs*YA2FcnkXKC1WS;3*_vryWiLdJG<+n4N)j_4B&+?EqV3oBFXGflh0l|H~In<@T86?Mnh@ zzTaDO{lZO@_bb0UcUz!c=kSzQeuG^YeEi~r;(&-7pWA0H?4p_h{nP&lc#a<}atw!^ z{d?wuMS(!^#b0`)zC`5@2KF264;(~ZcuI3BzY|rGwmHxuu1{3uBT8!dxyOZ`KL=)Z zIWWq78n#zk|GBv#a5B69u}i6b+RM2uW0^FU`c`dkJ;_W{=8NE2eSjs#%*|_HYd?sK5^eYD)8a* zT@S_;-9UNob$uS?nYlOb9Uk%m?ChxXdzyS_j<21&IAqUt*wd!}(`%)9dB9imyYz$Y z?H8NypAF`vuD@3v`}-P|A1HKfHaB##Cj2}Kw%0gS{>fIedwH)LeFndPm$xofR0{xHE&KB%6chyf5!^Xl6 z9{S+dT6@fy?b{4bbd$YrO<3+evvcoO@gufZVEsckhJA6sJo8KozxEOABJDl<%7f;# zo2LJ81K7bwN9vqDWUhKN^yP!a$&5!PFzVde->{(+cEh;!+&fT2y^H(0&Y3JY6R-82B zYL{5{J7v%x9`4$D3fo`L6}Jj@uyFOQ1ENcSZEFMY`^uyf33xr%q_D#yZ4XF@fZU(cM`!%X8fE_`%bnd zd;Xd`KWH^AGuP#$w(!T>RD^E4AEw z`~5J_tNbV;LzyZd-PyVU!nwHW@gZ*I4fRiAp+ ztXNc61h1Gy3*T`$n#VUSc+mdAWY7L%nGdX{*UYWwQ!|`Tr}*bI>AS>A zy=LB?cW7ZtW3)eFTHH6*;%jE&lBf=^>-nAr`{$30!RubaX2 z8=-Bpr+7{*JKj&ET{o+%B2qHL$N3|QuC)+_*UdU#zZg0(ce;Pf?z_W8@Va>?tNy$e z*)#on#y<7AaNjUz_WA6SlM`n8!(NPt7il-lQmaJ^G1BXAe{}j~Yw-5Vb1Yg3C+v68{-aGc!Ush_RIeOmeGtTNfPrv1p z&}yX8oc-`{_Sp;l{CmvQ7!j;A>s4;Ix6hgFzq@74eXHqBvv^B(#&6Zr{Htd7`rAsq zY2GO7*f4thH~#a9E9;2Do2GTQ0h-q?^1PJvXCo23X%@bH>f*zkS^nYgJc<(TTW0r% zi+UcYne3l^VllS=mYH*K?iWu!n(jGuX;~{#c+1>A?VXXI>LdJ}pKlek&fPK}EL(r7 z^O%L6oXXNFtLbg?jenI6Z+~;FCvDn*N-OoYdF7eCJ^R|e_3v37*+vxJHb*Tz{AyWc zrYCXzbA|}sHrr4Brrz$ci#%5TK^*@(X3MUv_pfn|^Q;@wsg}U~Y}x!FlR7$cJX03; zHALYZ^N>Gz)?3w6{I|P53;i9lRiB2}o~ZM=KWe}j_8%(LM7Qb7n}pjbF(FKJJAnU(c(callback: () => T) => T; +const scopes = new Set(); +export function registerRequestScope(scope: Scope): void { + scopes.add(scope); +} +export function runWithRequestScope(callback: () => T): T { + const entries = [...scopes]; + const run = (index: number): T => + index === entries.length + ? callback() + : entries[index](() => run(index + 1)); + return run(0); +} diff --git a/src/tooling/async.ts b/src/tooling/async.ts index 7e91152e..5bc91181 100644 --- a/src/tooling/async.ts +++ b/src/tooling/async.ts @@ -35,21 +35,44 @@ export async function lowerAsync( ], }, plugins: [ - () => ({ - visitor: { - Program(path) { - // Type-only `this` parameters must not contribute to the wrapper - // arity computed by Babel before esbuild strips TypeScript syntax. - path.traverse({ - Function(path) { - const first = path.node.params[0]; - if (first?.type === "Identifier" && first.name === "this") - path.node.params.shift(); - }, - }); + () => { + const intrinsicFunctions: Array<{ async: boolean }> = []; + return { + visitor: { + Program(path) { + // Type-only `this` parameters must not contribute to the wrapper + // arity computed by Babel before esbuild strips TypeScript syntax. + path.traverse({ + Function(path) { + const first = path.node.params[0]; + if (first?.type === "Identifier" && first.name === "this") + path.node.params.shift(); + // Empty anonymous async generators are used to discover native + // iterator intrinsics (including by workerd's events module). + // They have no continuation to instrument. Hide only this + // exact form from lowering, then restore its native syntax. + const node = path.node; + if ( + node.type === "FunctionExpression" && + !node.id && + node.async && + node.generator && + node.params.length === 0 && + node.body.body.length === 0 && + node.body.directives.length === 0 + ) { + intrinsicFunctions.push(node); + node.async = false; + } + }, + }); + }, }, - }, - }), + post() { + for (const node of intrinsicFunctions) node.async = true; + }, + }; + }, asyncGenerators, asyncFunctions, ], diff --git a/src/tooling/shared.ts b/src/tooling/shared.ts index b36fca1c..5b13c344 100644 --- a/src/tooling/shared.ts +++ b/src/tooling/shared.ts @@ -1,5 +1,6 @@ import stdlib from "node-stdlib-browser"; import { fileURLToPath } from "node:url"; +import { createRequire } from "node:module"; export const configuredPath = fileURLToPath( new URL("../configured.js", import.meta.url), @@ -19,6 +20,9 @@ export const globalsInstallPath = fileURLToPath( export const nodeGlobalsInstallPath = fileURLToPath( new URL("../shared/globals/node-install.js", import.meta.url), ); +export const processStatePath = fileURLToPath( + new URL("../compat/process/state.js", import.meta.url), +); export const nodeCompatPath = (name: string) => fileURLToPath(new URL(`../compat/${name}/index.js`, import.meta.url)); const workersModulePath = (name: string) => @@ -33,6 +37,16 @@ const polyfill = (specifier: string) => // One entry per builtin; subpaths precede parent aliases when expanded. // The optional third path is the CommonJS constructor entry. const builtins: readonly (readonly [string, string, string?])[] = [ + ["_http_common", "http-common/index.js"], + ["_http_outgoing", "http-outgoing/index.js"], + ["_http_server", "http-server/index.js"], + ["zlib", "zlib/index.js"], + ["crypto", "crypto/index.js", "crypto/index.cjs"], + ["console", "console/index.js"], + ["sys", "util/index.js"], + ["util/types", "util/types/index.js"], + ["events", "events/index.js", "events/index.cjs"], + ["process", "process/index.js", "process/index.cjs"], ["punycode", "punycode/index.js"], ["child_process", "child-process/index.js"], ["cluster", "cluster/index.js"], @@ -64,6 +78,9 @@ const builtins: readonly (readonly [string, string, string?])[] = [ ["tty", "tty/index.js"], ["url", "url/index.js"], ["diagnostics_channel", "diagnostics-channel/index.js"], + ["tls", "tls/index.js"], + ["_tls_wrap", "tls-wrap/index.js"], + ["_stream_wrap", "stream-wrap/index.js"], ["_tls_common", "tls-common/index.js"], ["async_hooks", "async-hooks/index.js"], ["timers/promises", "timers/promises.js", "timers/promises.cjs"], @@ -117,7 +134,14 @@ function builtinAliases(commonJS = false): Record { export function compatibilityAliases(): Record { return { - "process/": stdlib.process, + "process/": nodeCompatPath("process"), + // Preserve brorand's browser crypto:false branch across Vite aliases. + brorand: fileURLToPath( + new URL("../compat/crypto/brorand.cjs", import.meta.url), + ), + "cf-workers-native:process-base": createRequire(import.meta.url).resolve( + stdlib.process, + ), "cloudflare:node": workersModulePath("cloudflare-node"), "cloudflare:workers": workersModulePath("cloudflare-workers"), "punycode/": polyfill("punycode/punycode.js"), @@ -135,6 +159,7 @@ export function commonJSCompatibilityAliases(): Record { export function compatibilityDependencies(): string[] { return [ + processStatePath, "cloudflare:node", "cloudflare:workers", ...Object.keys(builtinAliases()), diff --git a/src/tooling/vite.ts b/src/tooling/vite.ts index 4e2fcc59..231c6a68 100644 --- a/src/tooling/vite.ts +++ b/src/tooling/vite.ts @@ -20,6 +20,7 @@ import { configuredPath, compatibilityAliases, compatibilityDependencies, + processStatePath, commonJSCompatibilityAliases, globalsInstallPath, nodeGlobalsInstallPath, @@ -168,8 +169,9 @@ function compatibilityPlugins( ...inject({ Buffer: [globalsInjectPath, "Buffer"], // util reads process during Buffer initialization. Keep this import - // independent of the injector that also imports Buffer. - process: [aliases["process/"], "default"], + // on the shared state leaf: importing the full process adapter here + // would cycle through events/util in optimized development chunks. + process: [processStatePath, "default"], global: [globalsRuntimePath, "global"], setImmediate: [globalsRuntimePath, "setImmediate"], clearImmediate: [globalsRuntimePath, "clearImmediate"], diff --git a/tests/unit/async-build.test.ts b/tests/unit/async-build.test.ts index b86e74d1..da6a2709 100644 --- a/tests/unit/async-build.test.ts +++ b/tests/unit/async-build.test.ts @@ -21,3 +21,49 @@ it("preserves runtime arity and receivers when lowering TypeScript async functio expect(original.length).toBe(1); expect(await original.call({ value: 4 }, 3)).toBe(7); }); + +it("preserves native async iterator identity through repeated build passes", async () => { + const source = `export const intrinsic = Object.getPrototypeOf( + Object.getPrototypeOf(async function* () {}).prototype + ); + export const empty = async function* () {};`; + const first = await lowerAsync(source, "worker.js", "js"); + // Vite transforms source modules and subsequently rendered chunks. + const second = await lowerAsync(first.code, "chunk.js", "js"); + const api = await import( + `data:text/javascript;base64,${Buffer.from(second.code).toString("base64")}` + ); + const native = Object.getPrototypeOf( + Object.getPrototypeOf(async function* () {}).prototype, + ); + expect(api.intrinsic).toBe(native); + const iterator = api.empty(); + expect(iterator[Symbol.asyncIterator]()).toBe(iterator); + expect(await iterator.next()).toEqual({ value: undefined, done: true }); +}); + +it("still lowers generators with continuations and preserves cancellation cleanup", async () => { + const source = `export const sequence = async function* () { + try { yield await Promise.resolve(1); yield 2; } + finally { globalThis.__asyncBuildCleanup = true; } + };`; + const lowered = await lowerAsync(source, "worker.js", "js"); + expect(lowered.code).not.toMatch(/async\s+function\s*\*/); + const { sequence } = await import( + `data:text/javascript;base64,${Buffer.from(lowered.code).toString("base64")}` + ); + const state = globalThis as typeof globalThis & { + __asyncBuildCleanup?: boolean; + }; + try { + const iterator = sequence(); + expect(await iterator.next()).toEqual({ value: 1, done: false }); + expect(await iterator.return("cancel")).toEqual({ + value: "cancel", + done: true, + }); + expect(state.__asyncBuildCleanup).toBe(true); + } finally { + delete state.__asyncBuildCleanup; + } +}); diff --git a/tests/unit/opennext-compat.test.ts b/tests/unit/opennext-compat.test.ts index 963f348e..54264ee0 100644 --- a/tests/unit/opennext-compat.test.ts +++ b/tests/unit/opennext-compat.test.ts @@ -28,13 +28,7 @@ it("module contract", async () => { expect(report.cases.filter((c) => c.status !== "passed")).toEqual([]); }); it("stream-web contract", async () => { - const nativeFile = Object.getOwnPropertyDescriptor(globalThis, "File")!; const release = installWebGlobals(); - const installedFile = Object.getOwnPropertyDescriptor(globalThis, "File")!; - // Undici's multipart parser constructs global File and then validates its - // private native brand. Keep that Node-only codec dependency for this test; - // the browser and workerd contracts exercise the installed File constructor. - Object.defineProperty(globalThis, "File", nativeFile); try { const report = await runContract( new StreamWebImplementation(localStreams), @@ -43,7 +37,6 @@ it("stream-web contract", async () => { expect(report.errors).toEqual([]); expect(report.cases.filter((c) => c.status !== "passed")).toEqual([]); } finally { - Object.defineProperty(globalThis, "File", installedFile); release(); } }); diff --git a/vitest.config.ts b/vitest.config.ts index e9be9ac3..0f205a33 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -46,6 +46,8 @@ export default defineConfig({ "src/browser/fetch/native-network.spec.ts", "src/browser/fetch/scope.spec.ts", "src/compat/net/sockets.spec.ts", + "src/compat/tls/upgrade.spec.ts", + "src/compat/fs/writable.spec.ts", "src/shared/http-wire/index.spec.ts", ], }, From eb5be9f4a3db435f55d1a4e6e7edcdd2bc91c579 Mon Sep 17 00:00:00 2001 From: rdlabo Date: Fri, 23 Oct 2026 08:00:40 +0900 Subject: [PATCH 2/8] feat: implement Workers Certificate SPKAC operations --- .../node-compat/completion-report.mjs | 2 +- .../experiments/node-compat/surface-gaps.json | 8 +- docs/compatibility.md | 2 +- src/compat/crypto/certificate.ts | 102 ++++++++++++++++++ src/compat/crypto/index.ts | 3 + src/compat/crypto/native-crypto.build.json | 4 +- src/compat/crypto/native-crypto.c | 17 +++ src/compat/crypto/native-crypto.ts | 10 ++ src/compat/crypto/native-crypto.wasm | Bin 1750462 -> 1753119 bytes src/compat/expansion/README.md | 7 +- src/compat/expansion/index.spec.mjs | 67 ++++++++++++ 11 files changed, 209 insertions(+), 13 deletions(-) create mode 100644 src/compat/crypto/certificate.ts diff --git a/demo/tests/experiments/node-compat/completion-report.mjs b/demo/tests/experiments/node-compat/completion-report.mjs index 44010851..0f7f1e7d 100644 --- a/demo/tests/experiments/node-compat/completion-report.mjs +++ b/demo/tests/experiments/node-compat/completion-report.mjs @@ -23,7 +23,7 @@ const assessments = [ modules: ["crypto", "zlib"], priority: 2, category: "implementation-gap", - next: "Inventory algorithms, key/codec classes, synchronous and streaming behavior. Evaluate JS/Wasm implementations against all pinned operations; random/hash/HKDF/scrypt, owned secret/asymmetric keys, RSA/EC/Ed25519 signatures, prime generation/checking and Brotli/Zstd profiles now supplement dependency polyfills. X509/Certificate, additional key-generation options, remaining algorithms and complete codec contracts remain open. No technical-impossibility claim has been established.", + next: "Inventory algorithms, key/codec classes, synchronous and streaming behavior. Evaluate JS/Wasm implementations against all pinned operations; random/hash/HKDF/scrypt, owned secret/asymmetric keys, RSA/EC/Ed25519 signatures, prime generation/checking and Brotli/Zstd profiles now supplement dependency polyfills. X509Certificate, additional key-generation options, remaining algorithms and complete codec contracts remain open. No technical-impossibility claim has been established.", evidence: [ "surface-gaps.json", "expansion-contracts.probe.mjs", diff --git a/demo/tests/experiments/node-compat/surface-gaps.json b/demo/tests/experiments/node-compat/surface-gaps.json index 71b6d795..a6519f84 100644 --- a/demo/tests/experiments/node-compat/surface-gaps.json +++ b/demo/tests/experiments/node-compat/surface-gaps.json @@ -1,13 +1,7 @@ { "common": { "crypto": { - "missing": [ - "Certificate", - "X509Certificate", - "fips", - "getCipherInfo", - "getFips" - ], + "missing": ["X509Certificate", "fips", "getCipherInfo", "getFips"], "extra": ["createCredentials", "listCiphers", "prng", "rng"] }, "fs": { diff --git a/docs/compatibility.md b/docs/compatibility.md index b274898a..899f8f26 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -34,7 +34,7 @@ establish equivalent methods, validation, state, scheduling or engine behavior. | fs / fs/promises | Read-only embedded files plus request-local in-memory `/tmp`, with writes, descriptors and FileHandle operations. Watch is unsupported, as in Workers. Full filesystem semantics remain under audit. | | module | Limited builtin registry; createRequire loads VFS JSON only. Executable modules must be bundled; arbitrary dynamic resolution is unsupported. | | process, console, util / util/types / sys | Incomplete exports or behavior. Engine introspection, call sites and host-object detection are not equivalent to Workers. | -| crypto and zlib | Selected profiles cover random/hash/HKDF/scrypt, secret/asymmetric keys, signatures, primes and Brotli/Zstd streaming. X509/Certificate, additional algorithms and full crypto/codec parity remain gaps. | +| crypto and zlib | Selected profiles cover random/hash/HKDF/scrypt, secret/asymmetric keys, signatures, primes and Brotli/Zstd streaming. X509Certificate, additional algorithms and full crypto/codec parity remain gaps. | | TLS and HTTP internals | TLS and HTTP internal imports resolve. Direct Node TLS exchange and hostname rejection are tested on native transports. Wrapping an existing socket is rejected before any TLS application write. Actual TLS upgrade and complete class/state contracts remain gaps. | | Streams | An owned implementation supplies byte streams and the tested Workers tee cancellation and pipeTo abort behavior on every host. Whole-module acceptance remains open. | | async_hooks | Build-transformed async functions retain scoped stores. Untransformed native async callbacks reject; arbitrary dynamic code and request-origin isolation are not fully supported. | diff --git a/src/compat/crypto/certificate.ts b/src/compat/crypto/certificate.ts new file mode 100644 index 00000000..4a389fba --- /dev/null +++ b/src/compat/crypto/certificate.ts @@ -0,0 +1,102 @@ +// @ts-nocheck +// Copyright (c) 2017-2022 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +// +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +import { nativeSpkac } from "./native-crypto.js"; +import { bytes } from "./validation.js"; +import { isAnyArrayBuffer } from "../util/types/index.js"; +const cryptoImpl = { + verifySpkac: (data) => nativeSpkac(data, 0), + exportPublicKey: (data) => nativeSpkac(data, 1), + exportChallenge: (data) => nativeSpkac(data, 2), +}; +import { Buffer } from "node:buffer"; + +function getArrayBufferOrView(value, name, encoding) { + if (typeof value === "string") + return Buffer.from(value, encoding === "buffer" ? undefined : encoding); + if (isAnyArrayBuffer(value)) return new Uint8Array(value); + return bytes(value, name); +} + +export function verifySpkac( + spkac: Buffer | ArrayBuffer | ArrayBufferView | string, + encoding?: string, +): boolean { + return cryptoImpl.verifySpkac(getArrayBufferOrView(spkac, "spkac", encoding)); +} + +export function exportPublicKey( + spkac: Buffer | ArrayBuffer | ArrayBufferView | string, + encoding?: string, +): Buffer { + const ret = cryptoImpl.exportPublicKey( + getArrayBufferOrView(spkac, "spkac", encoding), + ); + return ret ? Buffer.from(ret) : Buffer.alloc(0); +} + +export function exportChallenge( + spkac: Buffer | ArrayBuffer | ArrayBufferView | string, + encoding?: string, +): Buffer { + const ret = cryptoImpl.exportChallenge( + getArrayBufferOrView(spkac, "spkac", encoding), + ); + return ret ? Buffer.from(ret) : Buffer.alloc(0); +} + +// The legacy implementation of this exposed the Certificate +// object and required that users create an instance before +// calling the member methods. This API pattern has been +// deprecated, however, as the method implementations do not +// rely on any object state. + +export declare class Certificate { + constructor(); + verifySpkac: typeof verifySpkac; + exportPublicKey: typeof exportPublicKey; + exportChallenge: typeof exportChallenge; + static verifySpkac: typeof verifySpkac; + static exportPublicKey: typeof exportPublicKey; + static exportChallenge: typeof exportChallenge; +} + +// For backwards compatibility reasons, this cannot be converted into a +// ES6 Class. +export function Certificate(this: unknown): Certificate { + if (!(this instanceof Certificate)) { + return new Certificate(); + } + return this; +} + +Certificate.prototype.verifySpkac = verifySpkac; +Certificate.prototype.exportPublicKey = exportPublicKey; +Certificate.prototype.exportChallenge = exportChallenge; + +Certificate.exportChallenge = exportChallenge; +Certificate.exportPublicKey = exportPublicKey; +Certificate.verifySpkac = verifySpkac; diff --git a/src/compat/crypto/index.ts b/src/compat/crypto/index.ts index a6f94e70..f08f07d7 100644 --- a/src/compat/crypto/index.ts +++ b/src/compat/crypto/index.ts @@ -1,3 +1,5 @@ +import { Certificate } from "./certificate.js"; +export { Certificate }; import { ECDH, createECDH } from "./ecdh.js"; export { ECDH, createECDH }; import * as signatures from "./signatures.js"; @@ -102,6 +104,7 @@ export function hash( return outputEncoding === "buffer" ? result : result.toString(outputEncoding); } export default { + Certificate, ...original, ...metadata, ...asymmetric, diff --git a/src/compat/crypto/native-crypto.build.json b/src/compat/crypto/native-crypto.build.json index 57cb824c..b305bf42 100644 --- a/src/compat/crypto/native-crypto.build.json +++ b/src/compat/crypto/native-crypto.build.json @@ -34,6 +34,6 @@ "--no-entry", "-sEXPORTED_FUNCTIONS=[\"_malloc\",\"_free\"]" ], - "bindingSha256": "bc0d4d182a4bf3d67cce1517d779ebb46b67f49e418340b62cd9cdd08f02c376", - "sha256": "b0c0ed73e8d1b50e7092e48e13088e34b46742571b3488f4b99f71d109e62f20" + "bindingSha256": "bf5443ca18c7267973bffae11974fd1e457e88c1b224048beb606ab32121d285", + "sha256": "65203395b64d6985b192e32e5c4e249ae53633b34eb9430297b549b0e0584c74" } diff --git a/src/compat/crypto/native-crypto.c b/src/compat/crypto/native-crypto.c index cf018578..c670b036 100644 --- a/src/compat/crypto/native-crypto.c +++ b/src/compat/crypto/native-crypto.c @@ -216,3 +216,20 @@ API int wk_rsa(EVP_PKEY *key,int operation,const unsigned char *data,size_t leng status=1; done: EVP_PKEY_CTX_free(ctx);return status; } +API int wk_spkac(const unsigned char *data,int length,int operation) { + while(length>0 && (data[length-1]==' ' || data[length-1]=='\n' || data[length-1]=='\r' || data[length-1]=='\t'))length--; + if(!length)return 0; + NETSCAPE_SPKI *spki=NETSCAPE_SPKI_b64_decode((const char*)data,length);if(!spki)return 0; + int ok=0;EVP_PKEY *key=NULL;BIO *bio=NULL; + if(operation==2){ + const ASN1_IA5STRING *challenge=spki->spkac->challenge;clear_output();output_length=ASN1_STRING_length(challenge);output=OPENSSL_malloc(output_length?output_length:1); + if(output){memcpy(output,ASN1_STRING_get0_data(challenge),output_length);ok=1;} + } else { + key=NETSCAPE_SPKI_get_pubkey(spki); + if(key && operation==1){bio=BIO_new(BIO_s_mem());ok=bio && PEM_write_bio_PUBKEY(bio,key) && save_bio(bio);} + // Workers' FIPS backend rejects MD5 signatures. This is an API behavior + // restriction, not a claim that the bundled OpenSSL build is FIPS certified. + else if(key && OBJ_obj2nid(spki->sig_algor.algorithm)!=NID_md5WithRSAEncryption)ok=NETSCAPE_SPKI_verify(spki,key)==1; + } + BIO_free(bio);EVP_PKEY_free(key);NETSCAPE_SPKI_free(spki);return ok; +} diff --git a/src/compat/crypto/native-crypto.ts b/src/compat/crypto/native-crypto.ts index 25e9a8a9..b60cefa8 100644 --- a/src/compat/crypto/native-crypto.ts +++ b/src/compat/crypto/native-crypto.ts @@ -483,3 +483,13 @@ function ecFormat(format: string) { if (format === "hybrid") throw new Error("Failed to get public key length"); return format === "compressed" ? 2 : 4; } + +export function nativeSpkac( + data: Uint8Array, + operation: number, +): boolean | Uint8Array { + return inputs([data], (api, [p]) => { + const ok = api.wk_spkac(p, data.byteLength, operation); + return operation === 0 ? !!ok : ok ? result(api) : new Uint8Array(); + }); +} diff --git a/src/compat/crypto/native-crypto.wasm b/src/compat/crypto/native-crypto.wasm index b3cea63b527c5734fa253601855725be115aeb8d..be1c40ee7140842cc87f4d4b35e18f0e37c321d0 100755 GIT binary patch delta 658628 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%0DIrq}FQSt(V_#YB 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

dsQh~;H?pv%n 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 Y6n|J@^!b;|Rn1(br<67&sKL_T<5 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 { + const data = new TextEncoder().encode(value), + padded = new Uint8Array(data.length + 4); + padded.set(data, 2); + const view = new DataView(padded.buffer, 2, data.length); + const damaged = value.slice(0, -8) + "AAAAAAAA"; + return [ + describe(value), + describe(data.buffer), + describe(view), + describe(value + " \n\r\t"), + describe(damaged), + { + hex: api + .exportChallenge( + Array.from(data, (b) => b.toString(16).padStart(2, "0")).join(""), + "hex", + ) + .toString("hex"), + legacy: instance + .exportPublicKey(data) + .equals(api.exportPublicKey(data)), + called: called + .exportChallenge(data) + .equals(api.exportChallenge(data)), + bufferEncoding: api.exportChallenge(value, "buffer").toString("hex"), + }, + ]; + }); + const invalid = ["", " \n\t", "not-base64", "SPKAC=" + signatures[0]].map( + describe, + ); + const errors = []; + for (const name of ["verifySpkac", "exportPublicKey", "exportChallenge"]) + for (const value of [undefined, null, 42, {}]) { + try { + api[name](value); + errors.push(null); + } catch (e) { + errors.push({ name: e.name, code: e.code, message: e.message }); + } + } + return { + cases, + invalid, + errors, + instance: instance instanceof api, + called: called instanceof api, + methods: ["verifySpkac", "exportPublicKey", "exportChallenge"].map( + (n) => instance[n] === api[n], + ), + }; + }, + primeNumbers: async function ({ crypto }) { const capture = (fn) => { try { From 2467e00125fbab6a049fe185912aa82d4a966303 Mon Sep 17 00:00:00 2001 From: rdlabo Date: Fri, 23 Oct 2026 10:35:33 +0900 Subject: [PATCH 3/8] feat: add X509 certificates and authenticated socket TLS upgrades --- .../node-compat/completion-report.mjs | 4 +- .../node-compat/expansion-native.mjs | 209 +++++++- .../experiments/node-compat/surface-gaps.json | 2 +- docs/compatibility.md | 32 +- .../workerscapacitor/WorkerSockets.java | 59 ++- .../WorkersCapacitorPlugin.java | 2 + native/ios/NetworkBridge.swift | 10 + native/ios/SocketBridge.swift | 28 ++ native/ios/WorkersCapacitorPlugin.swift | 4 + scripts/build-native-crypto.mjs | 17 +- src/browser/fetch/host-call.ts | 4 + src/browser/fetch/native-network.ts | 2 + src/browser/fetch/relay.ts | 2 + src/compat/crypto/LICENSE-3RD-PARTY.md | 4 + src/compat/crypto/index.ts | 3 + src/compat/crypto/native-crypto.build.json | 5 +- src/compat/crypto/native-crypto.c | 303 ++++++++++++ src/compat/crypto/native-crypto.ts | 120 +++++ src/compat/crypto/native-crypto.wasm | Bin 1753119 -> 2293850 bytes src/compat/crypto/x509.ts | 463 ++++++++++++++++++ src/compat/expansion/README.md | 29 +- src/compat/expansion/index.spec.mjs | 143 ++++++ src/compat/net/sockets.spec.ts | 36 ++ src/compat/net/sockets.ts | 106 +++- src/compat/tls/native-session.ts | 181 +++++++ src/compat/tls/upgrade.spec.ts | 131 +++-- src/compat/tls/wrap.ts | 28 +- vitest.config.ts | 4 +- 28 files changed, 1813 insertions(+), 118 deletions(-) create mode 100644 src/compat/crypto/x509.ts create mode 100644 src/compat/tls/native-session.ts diff --git a/demo/tests/experiments/node-compat/completion-report.mjs b/demo/tests/experiments/node-compat/completion-report.mjs index 0f7f1e7d..56131e0c 100644 --- a/demo/tests/experiments/node-compat/completion-report.mjs +++ b/demo/tests/experiments/node-compat/completion-report.mjs @@ -23,7 +23,7 @@ const assessments = [ modules: ["crypto", "zlib"], priority: 2, category: "implementation-gap", - next: "Inventory algorithms, key/codec classes, synchronous and streaming behavior. Evaluate JS/Wasm implementations against all pinned operations; random/hash/HKDF/scrypt, owned secret/asymmetric keys, RSA/EC/Ed25519 signatures, prime generation/checking and Brotli/Zstd profiles now supplement dependency polyfills. X509Certificate, additional key-generation options, remaining algorithms and complete codec contracts remain open. No technical-impossibility claim has been established.", + next: "Inventory algorithms, key/codec classes, synchronous and streaming behavior. Evaluate JS/Wasm implementations against all pinned operations; random/hash/HKDF/scrypt, owned secret/asymmetric keys, RSA/EC/Ed25519 signatures, prime generation/checking X509Certificate parsing/fields/name checks/signature checks and Brotli/Zstd profiles now supplement dependency polyfills. Pinned Workers X509 key-check restrictions are documented. Additional key-generation options, remaining algorithms and complete codec contracts remain open. No technical-impossibility claim has been established.", evidence: [ "surface-gaps.json", "expansion-contracts.probe.mjs", @@ -104,7 +104,7 @@ const assessments = [ ], priority: 2, category: "implementation-and-native-transport", - next: "Audit class/prototype/state/event contracts together with native TCP/TLS behavior. Resolving internal imports or passing Fetch HTTP scenarios does not certify Node TLS/server APIs.", + next: "Direct TLS and same-connection STARTTLS exchange/hostname rejection are tested in page and Dedicated Worker on both OSes. TLS 1.2/1.3 and repeated write-half-close are covered on both OSes; custom Duplex wrapping remains unsupported. Audit remaining class/prototype/state/event contracts; these scenarios do not certify the whole TLS/server API.", evidence: ["surface-gaps.json", "../../../../docs/compatibility.md"], }, { diff --git a/demo/tests/experiments/node-compat/expansion-native.mjs b/demo/tests/experiments/node-compat/expansion-native.mjs index 49d3c9d6..49921493 100644 --- a/demo/tests/experiments/node-compat/expansion-native.mjs +++ b/demo/tests/experiments/node-compat/expansion-native.mjs @@ -1,3 +1,5 @@ +import { createServer as tcpServer } from "node:net"; +import { TLSSocket, createSecureContext } from "node:tls"; import { execFileSync } from "node:child_process"; import assert from "node:assert/strict"; import { readFile, mkdir, writeFile } from "node:fs/promises"; @@ -90,26 +92,39 @@ import { AsyncLocalStorage } from 'node:async_hooks'; import process from 'node:process'; export const run = name => eventCases[name]({process, tls, streams, sys, util, types, console, crypto, fs, zlib, module, httpCommon, httpOutgoing, httpServer, http}); export {createNetworkRelay, initializeWorkerNetwork} from ${JSON.stringify(consumer + "/node_modules/cf-workers-native/dist/browser/fetch/relay.js")}; -export const runTls = async port => { - const attempt = servername => new Promise((resolve,reject)=> { +export const runTls = async ({port,upgradePort}) => { + const attempt = (servername,halfClose=false) => new Promise((resolve,reject)=> { let accepted=false, body=''; const socket=tls.connect({host:'127.0.0.1',port,servername}); const timer=setTimeout(()=>{socket.destroy();reject(new Error('TLS timeout: '+servername));},8000); - socket.on('secureConnect',()=>{accepted=socket.authorized && socket.encrypted;socket.write('GET /tls-native HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n');}); + socket.on('secureConnect',()=>{accepted=socket.authorized && socket.encrypted;socket[halfClose?'end':'write']('GET /tls-native HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n');}); socket.on('data',chunk=>{body+=chunk.toString();}); socket.on('error',()=>{clearTimeout(timer);resolve({accepted,received:false});}); socket.on('end',()=>{clearTimeout(timer);resolve({accepted,received:body.includes('404') && body.includes('Not found')});}); }); - const valid=await attempt('localhost'), invalid=await attempt('wrong.invalid'); - const plain=net.connect({host:'127.0.0.1',port}); - plain.on('error',()=>{}); - let upgradeRejected=false; - try { - await new Promise((resolve,reject)=>{plain.once('connect',resolve);plain.once('error',reject);}); - try {tls.connect({socket:plain,servername:'localhost'}).write('must-never-be-plaintext');} - catch(error){if(error.code!=='ERR_METHOD_NOT_IMPLEMENTED')throw error;upgradeRejected=true;} - } finally {plain.destroy();} - return {valid,invalid,upgradeRejected}; + const valid=await attempt('localhost'), directEnd=await attempt('localhost',true), invalid=await attempt('wrong.invalid'); + + const upgrade = (servername,halfClose=false,legacy=false) => new Promise((resolve,reject)=>{ + const plain=net.connect({host:'127.0.0.1',port:upgradePort}); + let socket=plain, accepted=false, body='', greeting=''; + const timer=setTimeout(()=>{socket.destroy();plain.destroy();reject(new Error('Upgrade timeout: '+servername));},8000); + plain.on('error',()=>{}); + plain.on('connect',()=>plain.write(legacy==='untrusted'?'UNTRUSTED\\r\\n':legacy?'UPGRADE12\\r\\n':'UPGRADE\\r\\n')); + const onGreeting=chunk=>{ + greeting+=chunk.toString();if(!greeting.endsWith('\\r\\n'))return; + plain.off('data',onGreeting); + if(greeting!=='READY\\r\\n'){clearTimeout(timer);plain.destroy();reject(new Error('Invalid upgrade greeting'));return;} + socket=tls.connect({socket:plain,servername}); + socket.on('secureConnect',()=>{accepted=socket.authorized&&socket.encrypted;}); + socket.on('data',chunk=>{body+=chunk.toString();}); + socket.on('end',()=>{clearTimeout(timer);socket.destroy();plain.destroy();resolve({accepted,received:body==='encrypted-response'});}); + socket.on('error',()=>{clearTimeout(timer);plain.destroy();resolve({accepted,received:false});}); + if(halfClose)socket.end('encrypted-request');else socket.write('encrypted-request'); + }; + plain.on('data',onGreeting); + }); + const upgradeEnd=[];for(let i=0;i<3;i++)upgradeEnd.push(await upgrade('localhost',true)); + return {valid,directEnd,invalid,upgrade:await upgrade('localhost'),upgradeEnd,upgradeTls12:await upgrade('localhost',true,true),upgradeUntrusted:await upgrade('localhost',false,'untrusted'),upgradeInvalid:await upgrade('wrong.invalid')}; };`, }, bundle: true, @@ -210,13 +225,138 @@ execFileSync( ], { stdio: "pipe" }, ); +// A separate, currently valid self-signed chain is deliberately not installed +// in either OS trust store. Hostname-only validation must not accept it. +await writeFile( + `${tlsDirectory}/untrusted.cnf`, + (await readFile(`${tlsDirectory}/ca.cnf`, "utf8")).replace( + `${tlsDirectory}/key.pem`, + `${tlsDirectory}/untrusted-key.pem`, + ), +); +execFileSync( + "openssl", + [ + "req", + "-new", + "-newkey", + "rsa:2048", + "-nodes", + "-keyout", + `${tlsDirectory}/untrusted-key.pem`, + "-out", + `${tlsDirectory}/untrusted-request.pem`, + "-subj", + "/CN=Untrusted compatibility fixture", + ], + { stdio: "pipe" }, +); +execFileSync( + "openssl", + [ + "ca", + "-batch", + "-selfsign", + "-config", + `${tlsDirectory}/untrusted.cnf`, + "-in", + `${tlsDirectory}/untrusted-request.pem`, + "-out", + `${tlsDirectory}/untrusted.pem`, + "-startdate", + certificateTime(Date.now() - 86400000), + "-enddate", + certificateTime(Date.now() + 172800000), + ], + { stdio: "pipe" }, +); +const untrustedContext = createSecureContext({ + key: await readFile(`${tlsDirectory}/untrusted-key.pem`), + cert: await readFile(`${tlsDirectory}/untrusted.pem`), +}); +const upgradeStats = { connections: 0, requests: 0, unexpected: 0 }; +const upgradeProtocols = []; +const upgradeSockets = new Set(); +const context = createSecureContext({ + key: await readFile(`${tlsDirectory}/key.pem`), + cert: await readFile(`${tlsDirectory}/ca.pem`), +}); +const context12 = createSecureContext({ + key: await readFile(`${tlsDirectory}/key.pem`), + cert: await readFile(`${tlsDirectory}/ca.pem`), + maxVersion: "TLSv1.2", +}); +const upgradeServer = tcpServer((socket) => { + upgradeStats.connections++; + upgradeSockets.add(socket); + socket.on("close", () => upgradeSockets.delete(socket)); + socket.on("error", () => {}); + let greeting = ""; + const begin = (chunk) => { + greeting += chunk.toString(); + if (!greeting.endsWith("\r\n")) return; + socket.off("data", begin); + if (!["UPGRADE\r\n", "UPGRADE12\r\n", "UNTRUSTED\r\n"].includes(greeting)) { + upgradeStats.unexpected++; + socket.destroy(); + return; + } + socket.write("READY\r\n", () => { + const secure = new TLSSocket(socket, { + isServer: true, + secureContext: + greeting === "UNTRUSTED\r\n" + ? untrustedContext + : greeting === "UPGRADE12\r\n" + ? context12 + : context, + }); + secure.on("error", () => {}); + let body = ""; + secure.on("data", (chunk) => { + body += chunk.toString(); + if (body === "encrypted-request") { + upgradeStats.requests++; + upgradeProtocols.push(secure.getProtocol()); + secure.end("encrypted-response"); + } else if (!"encrypted-request".startsWith(body)) { + upgradeStats.unexpected++; + secure.destroy(); + } + }); + }); + }; + socket.on("data", begin); +}); +await new Promise((resolve) => upgradeServer.listen(0, "127.0.0.1", resolve)); +const tlsPorts = { port: 0, upgradePort: upgradeServer.address().port }; +if (platform === "android") + execFileSync("adb", [ + "-s", + device, + "reverse", + `tcp:${tlsPorts.upgradePort}`, + `tcp:${tlsPorts.upgradePort}`, + ]); const backend = await nativeBackend({ tlsDirectory, dispatch: async () => new Response("Not found", { status: 404 }), driver: "", - dispose: async () => {}, + dispose: async () => { + if (platform === "android") + execFileSync("adb", [ + "-s", + device, + "reverse", + "--remove", + `tcp:${tlsPorts.upgradePort}`, + ]); + for (const socket of upgradeSockets) socket.destroy(); + await new Promise((resolve) => upgradeServer.close(resolve)); + }, instrument: () => false, }); +tlsPorts.port = Number(backend.url.port); const bootstrapCode = ` async function main() { const source = ${JSON.stringify(source)}; @@ -247,7 +387,7 @@ try { } const tlsURL=URL.createObjectURL(new Blob([source],{type:'text/javascript'})); const tlsApi=await import(/* @vite-ignore */ tlsURL); - const nativeTls={page:await tlsApi.runTls(${JSON.stringify(Number(backend.url.port))})}; + const nativeTls={page:await tlsApi.runTls(${JSON.stringify(tlsPorts)})}; const workerURL=URL.createObjectURL(new Blob(['import {runTls, initializeWorkerNetwork} from '+JSON.stringify(tlsURL)+'; self.onmessage=async ({data})=>{try {await initializeWorkerNetwork();self.postMessage({tls:await runTls(data)});}catch(e){self.postMessage({error:String(e)});}};'],{type:'text/javascript'})); const tlsWorker=new Worker(workerURL,{type:'module'}); const relay=tlsApi.createNetworkRelay(tlsWorker); @@ -255,7 +395,7 @@ try { try {nativeTls.worker=await new Promise((resolve,reject)=>{ const timer=setTimeout(()=>reject(new Error('Worker TLS timeout')),20000); tlsWorker.onmessage=({data})=>{if(data.tls || data.error){clearTimeout(timer);data.error?reject(new Error(data.error)):resolve(data.tls);}}; - tlsWorker.postMessage(${JSON.stringify(Number(backend.url.port))}); + tlsWorker.postMessage(${JSON.stringify(tlsPorts)}); });} finally {tlsWorker.terminate();await relay.dispose();URL.revokeObjectURL(workerURL);URL.revokeObjectURL(tlsURL);} await report({stage:'complete', nativeTls, hash:${JSON.stringify(hash)}, results}); document.body.textContent = 'Compatibility contracts complete'; @@ -281,12 +421,47 @@ await runNativeAcceptance({ for (const mode of ["page", "worker"]) assert.deepEqual(completed.nativeTls[mode], { valid: { accepted: true, received: true }, + directEnd: { accepted: true, received: true }, invalid: { accepted: false, received: false }, - upgradeRejected: true, + upgrade: { accepted: true, received: true }, + upgradeEnd: Array.from({ length: 3 }, () => ({ + accepted: true, + received: true, + })), + upgradeTls12: { accepted: true, received: true }, + upgradeUntrusted: { accepted: false, received: false }, + upgradeInvalid: { accepted: false, received: false }, }); + assert.deepEqual(upgradeStats, { + connections: 14, + requests: 10, + unexpected: 0, + }); assert.deepEqual(Object.keys(completed.results).sort(), ["page", "worker"]); for (const mode of ["page", "worker"]) assert.deepEqual(completed.results[mode], baseline.results); + assert.equal( + upgradeProtocols.filter((protocol) => protocol === "TLSv1.3").length, + 8, + ); + assert.equal( + upgradeProtocols.filter((protocol) => protocol === "TLSv1.2").length, + 2, + ); + await writeFile( + `${artifacts}/tls-upgrade-evidence.json`, + JSON.stringify( + { + hash, + platform, + stats: upgradeStats, + protocols: upgradeProtocols, + results: completed.nativeTls, + }, + null, + 2, + ) + "\n", + ); }, }); console.log( diff --git a/demo/tests/experiments/node-compat/surface-gaps.json b/demo/tests/experiments/node-compat/surface-gaps.json index a6519f84..a3436104 100644 --- a/demo/tests/experiments/node-compat/surface-gaps.json +++ b/demo/tests/experiments/node-compat/surface-gaps.json @@ -1,7 +1,7 @@ { "common": { "crypto": { - "missing": ["X509Certificate", "fips", "getCipherInfo", "getFips"], + "missing": ["fips", "getCipherInfo", "getFips"], "extra": ["createCredentials", "listCiphers", "prng", "rng"] }, "fs": { diff --git a/docs/compatibility.md b/docs/compatibility.md index 899f8f26..1c45e204 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -27,22 +27,22 @@ and [verification scope](native-embedding.md#verification) for host-specific evi Whole-Node compatibility is incomplete. Importing a module successfully does not establish equivalent methods, validation, state, scheduling or engine behavior. -| Area | Behavior and limitations | -| ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| path, querystring, string_decoder, buffer, timers | Implement the pinned Workers profile. Workers stubs remain stubs; for example, matchesGlob reproduces the pinned rejection. | -| HTTP and net | In-memory server dispatch; no OS listening server. Outbound TCP/TLS requires the native transport. | -| fs / fs/promises | Read-only embedded files plus request-local in-memory `/tmp`, with writes, descriptors and FileHandle operations. Watch is unsupported, as in Workers. Full filesystem semantics remain under audit. | -| module | Limited builtin registry; createRequire loads VFS JSON only. Executable modules must be bundled; arbitrary dynamic resolution is unsupported. | -| process, console, util / util/types / sys | Incomplete exports or behavior. Engine introspection, call sites and host-object detection are not equivalent to Workers. | -| crypto and zlib | Selected profiles cover random/hash/HKDF/scrypt, secret/asymmetric keys, signatures, primes and Brotli/Zstd streaming. X509Certificate, additional algorithms and full crypto/codec parity remain gaps. | -| TLS and HTTP internals | TLS and HTTP internal imports resolve. Direct Node TLS exchange and hostname rejection are tested on native transports. Wrapping an existing socket is rejected before any TLS application write. Actual TLS upgrade and complete class/state contracts remain gaps. | -| Streams | An owned implementation supplies byte streams and the tested Workers tee cancellation and pipeTo abort behavior on every host. Whole-module acceptance remains open. | -| async_hooks | Build-transformed async functions retain scoped stores. Untransformed native async callbacks reject; arbitrary dynamic code and request-origin isolation are not fully supported. | -| diagnostics_channel | Synchronous channel/store contracts are implemented; async propagation depends on the async-hooks limitations. | -| worker_threads | Workers stubs and local MessagePort behavior, not Node threads. Trusted-event branding, host-object serialization and global identity differ. | -| DNS | DNS-over-HTTPS implementation; synthetic Service Binding/Hyperdrive address overrides are not implemented. | -| events | [WebView events profile](../src/compat/events/README.md): EventEmitter, abort/iteration helpers, transformed AsyncResource propagation and process warning delivery. Native async and V8 inspection remain bounded. | -| Other modules | Implementations and shared contracts exist, but whole-module acceptance remains outstanding. Namespace equality alone is insufficient. | +| Area | Behavior and limitations | +| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| path, querystring, string_decoder, buffer, timers | Implement the pinned Workers profile. Workers stubs remain stubs; for example, matchesGlob reproduces the pinned rejection. | +| HTTP and net | In-memory server dispatch; no OS listening server. Outbound TCP/TLS requires the native transport. | +| fs / fs/promises | Read-only embedded files plus request-local in-memory `/tmp`, with writes, descriptors and FileHandle operations. Watch is unsupported, as in Workers. Full filesystem semantics remain under audit. | +| module | Limited builtin registry; createRequire loads VFS JSON only. Executable modules must be bundled; arbitrary dynamic resolution is unsupported. | +| process, console, util / util/types / sys | Incomplete exports or behavior. Engine introspection, call sites and host-object detection are not equivalent to Workers. | +| crypto and zlib | Selected profiles cover random/hash/HKDF/scrypt, secret/asymmetric keys, signatures, primes and Brotli/Zstd streaming. X509Certificate parsing, fields and checks are implemented with the pinned Workers limits; additional algorithms and full crypto/codec parity remain gaps. | +| TLS and HTTP internals | TLS and HTTP internal imports resolve. Direct Node TLS exchange and hostname rejection are tested on native transports. Existing native sockets upgrade with authenticated TLS before application writes. TLS 1.2/1.3 upgrades are tested on both OSes; custom Duplex wrapping and complete class/state contracts remain gaps. | +| Streams | An owned implementation supplies byte streams and the tested Workers tee cancellation and pipeTo abort behavior on every host. Whole-module acceptance remains open. | +| async_hooks | Build-transformed async functions retain scoped stores. Untransformed native async callbacks reject; arbitrary dynamic code and request-origin isolation are not fully supported. | +| diagnostics_channel | Synchronous channel/store contracts are implemented; async propagation depends on the async-hooks limitations. | +| worker_threads | Workers stubs and local MessagePort behavior, not Node threads. Trusted-event branding, host-object serialization and global identity differ. | +| DNS | DNS-over-HTTPS implementation; synthetic Service Binding/Hyperdrive address overrides are not implemented. | +| events | [WebView events profile](../src/compat/events/README.md): EventEmitter, abort/iteration helpers, transformed AsyncResource propagation and process warning delivery. Native async and V8 inspection remain bounded. | +| Other modules | Implementations and shared contracts exist, but whole-module acceptance remains outstanding. Namespace equality alone is insufficient. | The exact missing/extra export baseline is maintained in [surface-gaps.json](../demo/tests/experiments/node-compat/surface-gaps.json), against diff --git a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java index 69969443..82c73cdd 100644 --- a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java +++ b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkerSockets.java @@ -33,13 +33,15 @@ private final class Connection extends SimpleChannelInboundHandler { final Result opening; final ArrayDeque chunks = new ArrayDeque<>(); SocketChannel channel; - Result reading, watching; + Result reading, watching, upgrading; + String host; int port; int count, offset; boolean ready, closed, eof, ended, writing, reset; Connection(String id, Result opening) { this.id=id; this.opening=opening; } void fail(String message) { if (closed) return; closed=true; + if(upgrading!=null) { Result pending=upgrading; upgrading=null; pending.reject(message); } if (!ready) { ready=true; opening.reject(message); } if (reading!=null) { Result pending=reading; reading=null; @@ -101,7 +103,7 @@ synchronized void open(String id,String host,int port,boolean tls,String servern SSLParameters parameters=engine.getSSLParameters(); parameters.setEndpointIdentificationAlgorithm("HTTPS"); engine.setSSLParameters(parameters); } else engine=null; if(group==null) group=new NioEventLoopGroup(1); - Connection connection=new Connection(id,result); connections.put(id,connection); + Connection connection=new Connection(id,result); connection.host=host; connection.port=port; connections.put(id,connection); ChannelFuture future=new Bootstrap().group(group).channel(NioSocketChannel.class) .option(ChannelOption.AUTO_READ,false).option(ChannelOption.ALLOW_HALF_CLOSURE,true) .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,30000) @@ -131,6 +133,37 @@ synchronized void open(String id,String host,int port,boolean tls,String servern }); } catch(Exception error) { Connection connection=connections.remove(id); if(connection!=null) connection.fail(error.toString()); else result.reject(error.toString()); } } + void startTls(String id,String servername,Result result) { + perform(id,result,connection -> { + if(connection.ended || connection.eof || connection.writing || connection.upgrading!=null || connection.channel.pipeline().get(SslHandler.class)!=null) { result.reject("Socket cannot be upgraded"); return; } + try { + final SSLEngine engine; + synchronized(this) { + if(tlsContext==null) { tlsContext=SSLContext.getInstance("TLS"); tlsContext.init(null,null,null); } + engine=tlsContext.createSSLEngine(servername==null || servername.isEmpty()?connection.host:servername,connection.port); + } + engine.setUseClientMode(true); + SSLParameters parameters=engine.getSSLParameters(); parameters.setEndpointIdentificationAlgorithm("HTTPS"); engine.setSSLParameters(parameters); + connection.upgrading=result; + JSObject moved=new JSObject(); moved.put("upgraded",true); + if(connection.reading!=null) { Result pending=connection.reading; connection.reading=null; pending.resolve(moved); } + if(connection.watching!=null) { Result pending=connection.watching; connection.watching=null; pending.resolve(moved); } + ArrayDeque buffered=new ArrayDeque<>(connection.chunks); connection.chunks.clear(); + int firstOffset=connection.offset; connection.offset=0; + SslHandler handler=new SslHandler(engine); + connection.channel.pipeline().addFirst(handler); + for(byte[] chunk:buffered) { + connection.channel.pipeline().fireChannelRead(Unpooled.wrappedBuffer(chunk,firstOffset,chunk.length-firstOffset)); firstOffset=0; + } + handler.handshakeFuture().addListener(handshake -> { + if(connection.closed) return; + if(!handshake.isSuccess()) { connection.fail("TLS failed: "+handshake.cause()); return; } + Result pending=connection.upgrading; connection.upgrading=null; pending.resolve(null); connection.pump(); + }); + connection.channel.read(); + } catch(Exception error) { result.reject(error.toString()); connection.fail(error.toString()); } + }); + } private static String authority(java.net.InetSocketAddress address) { String host=address.getAddress().getHostAddress(); return (host.contains(":")?"["+host+"]":host)+":"+address.getPort(); } @@ -164,7 +197,7 @@ void write(String id,String encoded,Result result) { try { chunk=Base64.decode(encoded,Base64.DEFAULT); } catch(Exception error) { result.reject("Invalid socket chunk"); return; } if(chunk.length>65536) { result.reject("Socket chunk exceeds limit"); return; } perform(id,result,connection -> { - if(connection.ended || connection.writing) { result.reject("Socket write unavailable"); return; } + if(connection.ended || connection.writing || connection.upgrading!=null) { result.reject("Socket write unavailable"); return; } connection.writing=true; connection.channel.writeAndFlush(Unpooled.wrappedBuffer(chunk)).addListener(future -> { connection.writing=false; @@ -175,11 +208,25 @@ void write(String id,String encoded,Result result) { void end(String id,Result result) { perform(id,result,true,connection -> { if(connection.reset) { result.resolve(null); return; } - if(connection.writing) { result.reject("Socket write still pending"); return; } + if(connection.writing || connection.upgrading!=null) { result.reject("Socket write still pending"); return; } if(connection.ended) { result.resolve(null); return; } connection.ended=true; - connection.channel.shutdownOutput().addListener(future -> { - if(future.isSuccess()) result.resolve(null); else { result.reject("Socket end failed"); connection.fail("Socket end failed"); } + Runnable shutdownOutput=() -> { + if(connection.eof && !connection.channel.isActive()) { result.resolve(null); return; } + connection.channel.shutdownOutput().addListener(future -> { + if(future.isSuccess() || connection.eof) result.resolve(null); + else { result.reject("Socket end failed"); connection.fail("Socket end failed"); } + }); + }; + SslHandler tls=connection.channel.pipeline().get(SslHandler.class); + if(tls==null) shutdownOutput.run(); + else tls.closeOutbound().addListener(future -> { + // TLS close_notify half-closes the TLS write side. Do not send + // TCP FIN here: it can close a peer's raw transport before its + // encrypted response has flushed. The read side owns final close. + if(future.isSuccess()) result.resolve(null); + else if(connection.eof) result.resolve(null); + else { result.reject("TLS end failed"); connection.fail("TLS end failed"); } }); }); } diff --git a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java index 4b948e94..c2ebc86d 100644 --- a/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java +++ b/native/android/src/main/java/jp/rdlabo/workerscapacitor/WorkersCapacitorPlugin.java @@ -110,6 +110,7 @@ private WorkerSockets.Result result(PluginCall call) { }; } + @PluginMethod public void socketStartTls(PluginCall call) { network.startTls(call.getString("id"),call.getString("servername"),result(call)); } @PluginMethod public void socketWatch(PluginCall call) { network.watch(call.getString("id"),result(call)); } @PluginMethod public void socketOpen(PluginCall call) { network.open(call.getString("id"),call.getString("host"),call.getInt("port",0),call.getBoolean("tls",false),call.getString("servername"),result(call)); @@ -246,6 +247,7 @@ private class HostBridge { } @JavascriptInterface public void cookiesGet(String callbackId,String url) { WorkersCapacitorPlugin.this.cookiesGet(url,hostResult(owner,callbackId)); } @JavascriptInterface public void cookiesSet(String callbackId,String url,String cookies) { WorkersCapacitorPlugin.this.cookiesSet(url,cookies,hostResult(owner,callbackId)); } + @JavascriptInterface public void socketStartTls(String callbackId,String id,String servername) { network.startTls(id,servername,hostResult(owner,callbackId)); } @JavascriptInterface public void socketWatch(String callbackId,String id) { network.watch(id,hostResult(owner,callbackId)); } @JavascriptInterface public void socketOpen(String callbackId,String id,String host,int port,boolean tls,String servername) { network.open(id,host,port,tls,servername,hostResult(owner,callbackId)); } @JavascriptInterface public void socketWrite(String callbackId,String id,String chunk) { network.write(id,chunk,hostResult(owner,callbackId)); } diff --git a/native/ios/NetworkBridge.swift b/native/ios/NetworkBridge.swift index c4c565b3..11f51aa0 100644 --- a/native/ios/NetworkBridge.swift +++ b/native/ios/NetworkBridge.swift @@ -22,6 +22,16 @@ final class NetworkBridge { } } } + func socketVerifyTls(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let encoded = call.getArray("certificates", String.self), encoded.count <= 32 else { reject(call, "Invalid certificate chain"); return } + let certificates = encoded.compactMap { $0.utf8.count <= 1048576 ? Data(base64Encoded: $0) : nil } + guard certificates.count == encoded.count else { reject(call, "Invalid certificate chain"); return } + sockets.verifyTls(id: id, certificates: certificates, completion: socketResult(call)) + } + func socketStartTls(_ call: CAPPluginCall) { + guard let id = call.getString("id") else { reject(call, "Missing socket"); return } + sockets.startTls(id: id, servername: call.getString("servername"), completion: socketResult(call)) + } func socketWatch(_ call: CAPPluginCall) { guard let id = call.getString("id") else { reject(call, "Missing socket"); return } sockets.watch(id: id, completion: socketResult(call)) diff --git a/native/ios/SocketBridge.swift b/native/ios/SocketBridge.swift index 0cba3458..f28c41ea 100644 --- a/native/ios/SocketBridge.swift +++ b/native/ios/SocketBridge.swift @@ -8,6 +8,8 @@ final class SocketBridge: @unchecked Sendable { private final class Connection: @unchecked Sendable { let id: String let transport: NWConnection + var encrypted = false + var host = "" var opening: ((Result) -> Void)? var reading: ((Result) -> Void)? var writing: ((Result) -> Void)? @@ -64,6 +66,7 @@ final class SocketBridge: @unchecked Sendable { } else { parameters = .tcp } let transport = NWConnection(host: NWEndpoint.Host(host), port: endpointPort, using: parameters) let value = Connection(id, transport) + value.host = host; value.encrypted = tls value.opening = completion self.values[id] = value transport.stateUpdateHandler = { [weak self, weak value] state in @@ -96,6 +99,31 @@ final class SocketBridge: @unchecked Sendable { transport.start(queue: self.queue) } } + func startTls(id: String, servername: String?, completion: @escaping Completion) { + queue.async { + guard let value = self.values[id], value.ready, !value.closed, !value.eof, !value.ended, !value.encrypted, value.writing == nil, + let hostname = servername, !hostname.isEmpty, !hostname.utf8.contains(0) else { completion(.failure(Failure.invalid)); return } + value.encrypted = true; value.host = hostname + value.reading?(.success(["upgraded": true])); value.reading = nil + value.watching?(.success(["upgraded": true])); value.watching = nil + // JS encrypts records with OpenSSL memory BIOs on this same TCP stream. + // The successful JS open is withheld until verifyTls authenticates it. + completion(.success(["tlsEngine": "openssl-wasm"])) + } + } + func verifyTls(id: String, certificates: [Data], completion: @escaping Completion) { + queue.async { + guard let value = self.values[id], !value.closed, value.encrypted, !certificates.isEmpty else { completion(.failure(Failure.invalid)); return } + let chain = certificates.compactMap { SecCertificateCreateWithData(nil, $0 as CFData) } + guard chain.count == certificates.count else { completion(.failure(Failure.invalid)); return } + var trust: SecTrust? + let policy = SecPolicyCreateSSL(true, value.host as CFString) + guard SecTrustCreateWithCertificates(chain as CFArray, policy, &trust) == errSecSuccess, let trust else { completion(.failure(Failure.invalid)); return } + var error: CFError? + guard SecTrustEvaluateWithError(trust, &error) else { completion(.failure(error as Error? ?? Failure.invalid)); return } + completion(.success([:])) + } + } func watch(id: String, completion: @escaping Completion) { queue.async { if let value = self.values[id], value.reset { completion(.success(["reset": true])); return } diff --git a/native/ios/WorkersCapacitorPlugin.swift b/native/ios/WorkersCapacitorPlugin.swift index 3a00fb38..9b8e471a 100644 --- a/native/ios/WorkersCapacitorPlugin.swift +++ b/native/ios/WorkersCapacitorPlugin.swift @@ -13,6 +13,8 @@ public final class WorkersCapacitorPlugin: CAPPlugin, CAPBridgedPlugin { CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "socketWatch", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "socketVerifyTls", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "socketStartTls", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "socketOpen", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "socketWrite", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "socketEnd", returnType: CAPPluginReturnPromise), @@ -69,6 +71,8 @@ public final class WorkersCapacitorPlugin: CAPPlugin, CAPBridgedPlugin { Task { await owner.closeAll(); call.resolve() } } } + @objc func socketVerifyTls(_ call: CAPPluginCall) { network.socketVerifyTls(call) } + @objc func socketStartTls(_ call: CAPPluginCall) { network.socketStartTls(call) } @objc func socketWatch(_ call: CAPPluginCall) { network.socketWatch(call) } @objc func socketOpen(_ call: CAPPluginCall) { network.socketOpen(call) } @objc func socketWrite(_ call: CAPPluginCall) { network.socketWrite(call) } diff --git a/scripts/build-native-crypto.mjs b/scripts/build-native-crypto.mjs index 1268c01a..24df1878 100644 --- a/scripts/build-native-crypto.mjs +++ b/scripts/build-native-crypto.mjs @@ -3,6 +3,7 @@ import { readFileSync, writeFileSync } from "node:fs"; import { resolve, join } from "node:path"; import { createHash } from "node:crypto"; import assert from "node:assert/strict"; +import { format, resolveConfig } from "prettier"; const sdk = resolve(process.env.CODEC_EMSDK ?? "artifacts/toolchains/emsdk"); const source = resolve("artifacts/upstream/openssl"); const revision = (directory) => @@ -70,6 +71,7 @@ execFileSync( [ binding, "-I" + join(source, "include"), + join(source, "libssl.a"), join(source, "libcrypto.a"), ...flags, "-o", @@ -79,17 +81,18 @@ execFileSync( ); const sha = (path) => createHash("sha256").update(readFileSync(path)).digest("hex"); +const manifest = "src/compat/crypto/native-crypto.build.json"; writeFileSync( - "src/compat/crypto/native-crypto.build.json", - JSON.stringify( - { + manifest, + await format( + JSON.stringify({ revisions, configure, flags, + libraries: ["libssl.a", "libcrypto.a"], bindingSha256: sha(binding), sha256: sha(output), - }, - null, - 2, - ) + "\n", + }), + { ...(await resolveConfig(manifest)), parser: "json" }, + ), ); diff --git a/src/browser/fetch/host-call.ts b/src/browser/fetch/host-call.ts index 4d3e5238..f0e84d22 100644 --- a/src/browser/fetch/host-call.ts +++ b/src/browser/fetch/host-call.ts @@ -3,6 +3,7 @@ import type { NativeCall } from "./native-network.js"; type Host = { cookiesGet(callback: string, url: string): void; cookiesSet(callback: string, url: string, cookies: string): void; + socketStartTls(callback: string, id: string, servername: string): void; socketWatch(callback: string, id: string): void; socketOpen( callback: string, @@ -67,6 +68,9 @@ export function getHostCall(): NativeCall | undefined { case "cookiesSet": host.cookiesSet(id, String(args.url), JSON.stringify(args.cookies)); break; + case "socketStartTls": + host.socketStartTls(id, handle, String(args.servername ?? "")); + break; case "socketWatch": host.socketWatch(id, handle); break; diff --git a/src/browser/fetch/native-network.ts b/src/browser/fetch/native-network.ts index 569adde6..b4c501bf 100644 --- a/src/browser/fetch/native-network.ts +++ b/src/browser/fetch/native-network.ts @@ -7,6 +7,8 @@ export type NativeNetworkMethod = | "cookiesSet" | "socketWatch" | "socketOpen" + | "socketStartTls" + | "socketVerifyTls" | "socketWrite" | "socketEnd" | "socketRead" diff --git a/src/browser/fetch/relay.ts b/src/browser/fetch/relay.ts index 86c8c02a..39c0f390 100644 --- a/src/browser/fetch/relay.ts +++ b/src/browser/fetch/relay.ts @@ -9,6 +9,8 @@ import { const methods = new Set([ "socketWatch", "socketOpen", + "socketStartTls", + "socketVerifyTls", "socketWrite", "socketEnd", "socketRead", diff --git a/src/compat/crypto/LICENSE-3RD-PARTY.md b/src/compat/crypto/LICENSE-3RD-PARTY.md index 88709535..7530a8e2 100644 --- a/src/compat/crypto/LICENSE-3RD-PARTY.md +++ b/src/compat/crypto/LICENSE-3RD-PARTY.md @@ -13,3 +13,7 @@ Copyright Cloudflare, Inc.; Apache License 2.0. Node.js/Joyent and Deno MIT notices are retained in the corresponding source files. Host transport and module imports are adapted for Capacitor. Public exports remain those of the pinned workerd module; internal helpers are not added to the public facade. + +X509 certificate wrappers and safe name rendering are adapted from +`src/node/internal/crypto_x509.ts` and `src/workerd/api/crypto/x509.c++` at +workerd commit `5358e3d337336eaf696a48bc1563d808b10feba5` (Apache-2.0). diff --git a/src/compat/crypto/index.ts b/src/compat/crypto/index.ts index f08f07d7..942e2dad 100644 --- a/src/compat/crypto/index.ts +++ b/src/compat/crypto/index.ts @@ -1,3 +1,5 @@ +import { X509Certificate } from "./x509.js"; +export { X509Certificate }; import { Certificate } from "./certificate.js"; export { Certificate }; import { ECDH, createECDH } from "./ecdh.js"; @@ -104,6 +106,7 @@ export function hash( return outputEncoding === "buffer" ? result : result.toString(outputEncoding); } export default { + X509Certificate, Certificate, ...original, ...metadata, diff --git a/src/compat/crypto/native-crypto.build.json b/src/compat/crypto/native-crypto.build.json index b305bf42..fdd5bb62 100644 --- a/src/compat/crypto/native-crypto.build.json +++ b/src/compat/crypto/native-crypto.build.json @@ -34,6 +34,7 @@ "--no-entry", "-sEXPORTED_FUNCTIONS=[\"_malloc\",\"_free\"]" ], - "bindingSha256": "bf5443ca18c7267973bffae11974fd1e457e88c1b224048beb606ab32121d285", - "sha256": "65203395b64d6985b192e32e5c4e249ae53633b34eb9430297b549b0e0584c74" + "libraries": ["libssl.a", "libcrypto.a"], + "bindingSha256": "819bf16122da0df3c5ce7b6158b23700b8d42778fcb0e14f3a9e054d5f68831f", + "sha256": "b25197493fce8f3b40615654f877b3dec064d90e3cd1a34dc86695dd3bb68c50" } diff --git a/src/compat/crypto/native-crypto.c b/src/compat/crypto/native-crypto.c index c670b036..fd193da5 100644 --- a/src/compat/crypto/native-crypto.c +++ b/src/compat/crypto/native-crypto.c @@ -233,3 +233,306 @@ API int wk_spkac(const unsigned char *data,int length,int operation) { } BIO_free(bio);EVP_PKEY_free(key);NETSCAPE_SPKI_free(spki);return ok; } + +// Name rendering adapted from workerd crypto/x509.c++ (Apache-2.0). +#include +#include +static const int kX509NameFlagsRFC2253WithinUtf8JSON = XN_FLAG_RFC2253 & ~ASN1_STRFLGS_ESC_MSB & ~ASN1_STRFLGS_ESC_CTRL; +int isSafeAltName(const char* name, size_t length, int utf8) { + for (size_t i = 0; i < length; i++) { + char c = name[i]; + switch (c) { + case '"': + case '\\': + // These mess with encoding rules. + // Fall through. + case ',': + // Commas make it impossible to split the list of subject alternative + // names unambiguously, which is why we have to escape. + // Fall through. + case '\'': + // Single quotes are unlikely to appear in any legitimate values, but they + // could be used to make a value look like it was escaped (i.e., enclosed + // in single/double quotes). + return 0; + default: + if (utf8) { + // In UTF8 strings, we require escaping for any ASCII control character, + // but NOT for non-ASCII characters. Note that all bytes of any code + // point that consists of more than a single byte have their MSB set. + if (((unsigned char)c) < ' ' || c == '\x7f') { + return 0; + } + } else { + // Check if the char is a control character or non-ASCII character. Note + // that char may or may not be a signed type. Regardless, non-ASCII + // values will always be outside of this range. + if (c < ' ' || c > '~') { + return 0; + } + } + } + } + return 1; +} + +void printAltName(BIO* out, const char* name, size_t length, int utf8, const char* safe_prefix) { + if (isSafeAltName(name, length, utf8)) { + // For backward-compatibility, append "safe" names without any + // modifications. + if (safe_prefix != NULL) { + BIO_printf(out, "%s:", safe_prefix); + } + BIO_write(out, name, length); + } else { + // If a name is not "safe", we cannot embed it without special + // encoding. This does not usually happen, but we don't want to hide + // it from the user either. We use JSON compatible escaping here. + BIO_write(out, "\"", 1); + if (safe_prefix != NULL) { + BIO_printf(out, "%s:", safe_prefix); + } + for (size_t j = 0; j < length; j++) { + char c = name[j]; + if (c == '\\') { + BIO_write(out, "\\\\", 2); + } else if (c == '"') { + BIO_write(out, "\\\"", 2); + } else if ((c >= ' ' && c != ',' && c <= '~') || (utf8 && (c & 0x80))) { + // Note that the above condition explicitly excludes commas, which means + // that those are encoded as Unicode escape sequences in the "else" + // block. That is not strictly necessary, and Node.js itself would parse + // it correctly either way. We only do this to account for third-party + // code that might be splitting the string at commas (as Node.js itself + // used to do). + BIO_write(out, &c, 1); + } else { + // Control character or non-ASCII character. We treat everything as + // Latin-1, which corresponds to the first 255 Unicode code points. + const char hex[] = "0123456789abcdef"; + char u[] = {'\\', 'u', '0', '0', hex[(c & 0xf0) >> 4], hex[c & 0x0f]}; + BIO_write(out, u, sizeof(u)); + } + } + BIO_write(out, "\"", 1); + } +} + +void printLatin1AltName(BIO* out, const ASN1_IA5STRING* name, const char* safe_prefix) { + printAltName(out, (const char*)name->data, name->length, 0, safe_prefix); +} + +void printUtf8AltName(BIO* out, const ASN1_UTF8STRING* name, const char* safe_prefix) { + printAltName(out, (const char*)name->data, name->length, 1, safe_prefix); +} + +int printGeneralName(BIO* out, const GENERAL_NAME* gen) { + if (gen->type == GEN_DNS) { + ASN1_IA5STRING* name = gen->d.dNSName; + BIO_write(out, "DNS:", 4); + // Note that the preferred name syntax (see RFCs 5280 and 1034) with + // wildcards is a subset of what we consider "safe", so spec-compliant DNS + // names will never need to be escaped. + printLatin1AltName(out, name, NULL); + } else if (gen->type == GEN_EMAIL) { + ASN1_IA5STRING* name = gen->d.rfc822Name; + BIO_write(out, "email:", 6); + printLatin1AltName(out, name, NULL); + } else if (gen->type == GEN_URI) { + ASN1_IA5STRING* name = gen->d.uniformResourceIdentifier; + BIO_write(out, "URI:", 4); + // The set of "safe" names was designed to include just about any URI, + // with a few exceptions, most notably URIs that contains commas (see + // RFC 2396). In other words, most legitimate URIs will not require + // escaping. + printLatin1AltName(out, name, NULL); + } else if (gen->type == GEN_DIRNAME) { + // Earlier versions of Node.js used X509_NAME_oneline to print the X509_NAME + // object. The format was non standard and should be avoided. The use of + // X509_NAME_oneline is discouraged by OpenSSL but was required for backward + // compatibility. Conveniently, X509_NAME_oneline produced ASCII and the + // output was unlikely to contains commas or other characters that would + // require escaping. However, it SHOULD NOT produce ASCII output since an + // RFC5280 AttributeValue may be a UTF8String. + // Newer versions of Node.js have since switched to X509_NAME_print_ex to + // produce a better format at the cost of backward compatibility. The new + // format may contain Unicode characters and it is likely to contain commas, + // which require escaping. Fortunately, the recently safeguarded function + // PrintAltName handles all of that safely. + BIO_printf(out, "DirName:"); + BIO *tmp = BIO_new(BIO_s_mem()); if (!tmp) return 0; + if (X509_NAME_print_ex(tmp, gen->d.dirn, 0, kX509NameFlagsRFC2253WithinUtf8JSON) < 0) { + BIO_free(tmp); return 0; + } + char* oline = NULL; + long n_bytes = BIO_get_mem_data(tmp, &oline); // NOLINT(runtime/int) + + if (n_bytes < 0 || (n_bytes > 0 && oline == NULL)) { BIO_free(tmp); return 0; } + + printAltName(out, oline, (size_t)n_bytes, 1, NULL); BIO_free(tmp); + } else if (gen->type == GEN_IPADD) { + BIO_printf(out, "IP Address:"); + const ASN1_OCTET_STRING* ip = gen->d.ip; + const unsigned char* b = ip->data; + if (ip->length == 4) { + BIO_printf(out, "%d.%d.%d.%d", b[0], b[1], b[2], b[3]); + } else if (ip->length == 16) { + for (unsigned int j = 0; j < 8; j++) { + uint16_t pair = (b[2 * j] << 8) | b[2 * j + 1]; + BIO_printf(out, (j == 0) ? "%X" : ":%X", pair); + } + } else { + BIO_printf(out, ""); + } + } else if (gen->type == GEN_RID) { + // Unlike OpenSSL's default implementation, never print the OID as text and + // instead always print its numeric representation. + char oline[256] = {0}; + OBJ_obj2txt(oline, sizeof(oline), gen->d.rid, 1); + BIO_printf(out, "Registered ID:%s", oline); + } else if (gen->type == GEN_OTHERNAME) { + // The pinned Workers BoringSSL build uses the pre-OpenSSL-3 rendering. + BIO_printf(out, "othername:"); + } else if (gen->type == GEN_X400) { + // TODO(tniessen): this is what OpenSSL does, implement properly instead + BIO_printf(out, "X400Name:"); + } else if (gen->type == GEN_EDIPARTY) { + // TODO(tniessen): this is what OpenSSL does, implement properly instead + BIO_printf(out, "EdiPartyName:"); + } else { + // This is safe because X509V3_EXT_d2i would have returned NULL in this + // case already. + return 0; + } + + return 1; +} + +int safeX509SubjectAltNamePrint(BIO* out, X509_EXTENSION* ext) { + + + GENERAL_NAMES* names = (GENERAL_NAMES*)X509V3_EXT_d2i(ext); + if (names == NULL) return 0; + + int ok = 1; + + for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) { + GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i); + + if (i != 0) BIO_write(out, ", ", 2); + + if (!(ok = printGeneralName(out, gen))) { + break; + } + } + sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free); + + return ok; +} + +int safeX509InfoAccessPrint(BIO* out, X509_EXTENSION* ext) { + + + AUTHORITY_INFO_ACCESS* descs = (AUTHORITY_INFO_ACCESS*)X509V3_EXT_d2i(ext); + if (descs == NULL) return 0; + + int ok = 1; + + for (int i = 0; i < sk_ACCESS_DESCRIPTION_num(descs); i++) { + ACCESS_DESCRIPTION* desc = sk_ACCESS_DESCRIPTION_value(descs, i); + + if (i != 0) BIO_write(out, "\n", 1); + + char objtmp[80] = {0}; + i2t_ASN1_OBJECT(objtmp, sizeof(objtmp), desc->method); + BIO_printf(out, "%s - ", objtmp); + if (!(ok = printGeneralName(out, desc->location))) { + break; + } + } + sk_ACCESS_DESCRIPTION_pop_free(descs, ACCESS_DESCRIPTION_free); + + // BoringSSL follows the pre-OpenSSL-3 infoAccess representation. + BIO_write(out, "\n", 1); + + return ok; +} + + +API X509 *wk_x509_parse(const unsigned char *data, int length) { + ERR_clear_error(); BIO *bio=BIO_new_mem_buf(data,length); if(!bio)return NULL; + X509 *cert=PEM_read_bio_X509_AUX(bio,NULL,NULL,NULL); BIO_free(bio); + if(!cert){ERR_clear_error();const unsigned char *p=data;cert=d2i_X509(NULL,&p,length);} + ERR_clear_error();return cert; +} +API void wk_x509_free(X509 *cert) {X509_free(cert);} +API EVP_PKEY *wk_x509_key(X509 *cert) {return X509_get_pubkey(cert);} +API int wk_x509_ca(X509 *cert) {return X509_check_ca(cert)==1;} +API int wk_x509_compare(X509 *cert,void *other,int operation) { + ERR_clear_error(); int ok=operation==0?X509_check_issued(other,cert)==X509_V_OK:operation==1?X509_check_private_key(cert,other)==1:X509_verify(cert,other)==1; + ERR_clear_error();return ok; +} +API int wk_x509_check(X509 *cert,const char *name,int length,int flags,int operation) { + char *peer=NULL;ERR_clear_error();clear_output(); + int ok=operation==0?X509_check_host(cert,name,length,flags,&peer):operation==1?X509_check_email(cert,name,length,flags):X509_check_ip_asc(cert,name,flags); + if(ok==1){output_length=peer?strlen(peer):(size_t)length;output=OPENSSL_memdup(peer?peer:name,output_length);if(!output)ok=-1;} + OPENSSL_free(peer);ERR_clear_error();return ok; +} +static void x509_name_part(BIO *bio,const void *data,int length) { + unsigned char size[4]={(unsigned int)length>>24,(unsigned int)length>>16,(unsigned int)length>>8,(unsigned int)length}; + BIO_write(bio,size,4);BIO_write(bio,data,length); +} +API int wk_x509_field(X509 *cert,int field) { + ERR_clear_error();clear_output(); BIO *bio=BIO_new(BIO_s_mem());if(!bio)return 0;int ok=1; + switch(field) { + case 0: case 1: ok=X509_NAME_print_ex(bio,field==0?X509_get_subject_name(cert):X509_get_issuer_name(cert),0,ASN1_STRFLGS_ESC_2253|ASN1_STRFLGS_ESC_CTRL|ASN1_STRFLGS_UTF8_CONVERT|XN_FLAG_SEP_MULTILINE|XN_FLAG_FN_SN)>0;break; + case 2: case 3: {int index=X509_get_ext_by_NID(cert,field==2?NID_subject_alt_name:NID_info_access,-1);ok=index>=0;if(ok)ok=field==2?safeX509SubjectAltNamePrint(bio,X509_get_ext(cert,index)):safeX509InfoAccessPrint(bio,X509_get_ext(cert,index));break;} + case 4: case 5: ok=ASN1_TIME_print(bio,field==4?X509_get0_notBefore(cert):X509_get0_notAfter(cert));break; + case 6: case 7: case 8: {unsigned char digest[EVP_MAX_MD_SIZE];unsigned int size=0;ok=X509_digest(cert,field==6?EVP_sha1():field==7?EVP_sha256():EVP_sha512(),digest,&size);if(ok)for(unsigned int i=0;i0;if(ok)BIO_write(bio,data,length);OPENSSL_free(data);EC_KEY_free(ec);EVP_PKEY_free(key);break;} + default:ok=0; + } + if(ok)ok=save_bio(bio);BIO_free(bio);ERR_clear_error();return ok; +} + +// Memory-BIO TLS for platforms whose connected transport cannot add TLS. +// The host MUST authenticate the peer chain and hostname before exposing data. +#include +API SSL *wk_tls_new(const char *host) { + ERR_clear_error(); SSL_CTX *ctx=SSL_CTX_new(TLS_client_method());if(!ctx)return NULL; + SSL_CTX_set_min_proto_version(ctx,TLS1_2_VERSION); + // Trust is evaluated by the OS (SecTrust), not a separate bundled CA store. + SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL); + SSL *ssl=SSL_new(ctx);SSL_CTX_free(ctx);if(!ssl)return NULL; + BIO *read=BIO_new(BIO_s_mem()),*write=BIO_new(BIO_s_mem()); + if(!read || !write){BIO_free(read);BIO_free(write);SSL_free(ssl);return NULL;} + BIO_set_mem_eof_return(read,-1);BIO_set_mem_eof_return(write,-1); + SSL_set_bio(ssl,read,write);SSL_set_connect_state(ssl); + SSL_set_mode(ssl,SSL_MODE_ENABLE_PARTIAL_WRITE|SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER); + if(host && *host && !SSL_set_tlsext_host_name(ssl,host)){SSL_free(ssl);return NULL;} + return ssl; +} +API void wk_tls_free(SSL *ssl){SSL_free(ssl);} +API int wk_tls_feed(SSL *ssl,const unsigned char *data,int length){return BIO_write(SSL_get_rbio(ssl),data,length)==length;} +API int wk_tls_handshake(SSL *ssl){ERR_clear_error();int r=SSL_do_handshake(ssl);return r==1?1:-SSL_get_error(ssl,r);} +API int wk_tls_read(SSL *ssl){ + ERR_clear_error();clear_output();output_length=65536;output=OPENSSL_malloc(output_length);if(!output)return -1; + int r=SSL_read(ssl,output,output_length);if(r>0){output_length=r;return r;}int error=SSL_get_error(ssl,r);clear_output();return -error; +} +API int wk_tls_write(SSL *ssl,const unsigned char *data,int length){ERR_clear_error();int r=SSL_write(ssl,data,length);return r>0?r:-SSL_get_error(ssl,r);} +API int wk_tls_drain(SSL *ssl){ + clear_output();size_t size=BIO_ctrl_pending(SSL_get_wbio(ssl));if(!size)return 0;if(size>65536)size=65536; + output=OPENSSL_malloc(size);output_length=size;if(!output)return -1; + int r=BIO_read(SSL_get_wbio(ssl),output,size);if(r>0){output_length=r;return r;}clear_output();return -1; +} +API int wk_tls_shutdown(SSL *ssl){ERR_clear_error();int r=SSL_shutdown(ssl);return r>=0?r:-SSL_get_error(ssl,r);} +API int wk_tls_certificate(SSL *ssl,int index){ + STACK_OF(X509) *chain=SSL_get_peer_cert_chain(ssl);if(!chain || index<0 || index>=sk_X509_num(chain))return 0; + BIO *bio=BIO_new(BIO_s_mem());if(!bio)return 0;int ok=i2d_X509_bio(bio,sk_X509_value(chain,index));if(ok)ok=save_bio(bio);BIO_free(bio);return ok; +} diff --git a/src/compat/crypto/native-crypto.ts b/src/compat/crypto/native-crypto.ts index b60cefa8..ce2beb36 100644 --- a/src/compat/crypto/native-crypto.ts +++ b/src/compat/crypto/native-crypto.ts @@ -123,6 +123,9 @@ const released = new FinalizationRegistry((pointer) => library().wk_key_free(pointer), ); export class NativeKey { + checkCertificate(cert: number, operation: number) { + return library().wk_x509_compare(cert, this.handle(), operation) === 1; + } rsa(operation: number, data: Uint8Array, options: any): Uint8Array { if (this.type !== "rsa") throw new Error("publicEncrypt() currently only supports RSA keys"); @@ -493,3 +496,120 @@ export function nativeSpkac( return operation === 0 ? !!ok : ok ? result(api) : new Uint8Array(); }); } + +const x509Released = new FinalizationRegistry((pointer) => + library().wk_x509_free(pointer), +); +export class NativeX509 { + private constructor(private pointer: number) { + x509Released.register(this, pointer); + } + static parse(data: Uint8Array) { + return inputs([data], (api, [p]) => { + const pointer = api.wk_x509_parse(p, data.byteLength); + return pointer ? new NativeX509(pointer) : undefined; + }); + } + field(field: number): Uint8Array | undefined { + const api = library(); + return api.wk_x509_field(this.pointer, field) ? result(api) : undefined; + } + string(field: number): string | undefined { + const value = this.field(field); + return value === undefined ? undefined : decoder.decode(value); + } + get isCA() { + return library().wk_x509_ca(this.pointer) === 1; + } + get publicKey() { + const pointer = library().wk_x509_key(this.pointer); + return pointer ? new NativeKey(pointer) : undefined; + } + check(name: string, flags: number, operation: number) { + return inputs([name], (api, [p]) => { + const status = api.wk_x509_check( + this.pointer, + p, + encoder.encode(name).length, + flags, + operation, + ); + if (status < 0) + throw new Error( + status === -2 + ? operation === 2 + ? "Invalid IP" + : "Invalid name" + : "Operation failed", + ); + return status === 1 ? decoder.decode(result(api)) : undefined; + }); + } + checkIssued(other: NativeX509) { + return library().wk_x509_compare(this.pointer, other.pointer, 0) === 1; + } + checkKey(key: NativeKey, operation: number) { + return key.checkCertificate(this.pointer, operation); + } +} + +const tlsReleased = new FinalizationRegistry((pointer) => + library().wk_tls_free(pointer), +); +export class NativeTLS { + private pointer: number; + constructor(host: string) { + this.pointer = inputs([host], (api, [p]) => api.wk_tls_new(p)); + if (!this.pointer) throw error(); + tlsReleased.register(this, this.pointer, this); + } + private handle() { + if (!this.pointer) throw new Error("TLS session closed"); + return this.pointer; + } + dispose() { + if (this.pointer) { + library().wk_tls_free(this.pointer); + this.pointer = 0; + tlsReleased.unregister(this); + } + } + feed(data: Uint8Array) { + inputs([data], (api, [p]) => { + if (!api.wk_tls_feed(this.handle(), p, data.byteLength)) throw error(); + }); + } + handshake(): number { + return library().wk_tls_handshake(this.handle()); + } + read(): number | Uint8Array { + const api = library(), + status = api.wk_tls_read(this.handle()); + return status > 0 ? result(api) : status; + } + write(data: Uint8Array): number { + return inputs([data], (api, [p]) => + api.wk_tls_write(this.handle(), p, data.byteLength), + ); + } + shutdown(): number { + return library().wk_tls_shutdown(this.handle()); + } + drain(): Uint8Array[] { + const api = library(), + chunks: Uint8Array[] = []; + for (;;) { + const status = api.wk_tls_drain(this.handle()); + if (status === 0) return chunks; + if (status < 0) throw error(); + chunks.push(result(api)); + } + } + certificates(): Uint8Array[] { + const api = library(), + certs: Uint8Array[] = []; + for (let i = 0; api.wk_tls_certificate(this.handle(), i); i++) + certs.push(result(api)); + return certs; + } +} diff --git a/src/compat/crypto/native-crypto.wasm b/src/compat/crypto/native-crypto.wasm index be1c40ee7140842cc87f4d4b35e18f0e37c321d0..3bb0cca00fa9564305802c821ebf4c01a4b6ded8 100755 GIT binary patch literal 2293850 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

VX#Bq>l`>j;O3LT*H;$v2c%tFIvdG|TRUr0h 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≧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%0D}@(*-*Q6M~< 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

2UF}X?i05QR@v(NMm@M%EN?lN^ZQQ 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

Zzzx>Zzzx>Zzzx>Zzzx>Zzzx>Zzzx>Zzzx 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 z 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�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

T_7NU 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