;
+ }
+}
diff --git a/ext/quic/lib.rs b/ext/quic/lib.rs
new file mode 100644
index 00000000000000..3a6a43868d26fb
--- /dev/null
+++ b/ext/quic/lib.rs
@@ -0,0 +1,604 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use deno_core::error::generic_error;
+use deno_core::error::type_error;
+use deno_core::error::AnyError;
+use deno_core::op2;
+use deno_core::AsyncRefCell;
+use deno_core::AsyncResult;
+use deno_core::BufView;
+use deno_core::OpState;
+use deno_core::RcRef;
+use deno_core::Resource;
+use deno_core::ResourceId;
+use deno_core::WriteOutcome;
+use deno_net::resolve_addr::resolve_addr;
+use deno_net::DefaultTlsOptions;
+use deno_net::NetPermissions;
+use deno_net::UnsafelyIgnoreCertificateErrors;
+use deno_tls::create_client_config;
+use deno_tls::load_certs;
+use deno_tls::load_private_keys;
+use deno_tls::RootCertStoreProvider;
+use deno_tls::SocketUse;
+use serde::Deserialize;
+use serde::Serialize;
+use std::borrow::Cow;
+use std::cell::RefCell;
+use std::io::BufReader;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::Arc;
+
+pub fn get_declaration() -> PathBuf {
+ PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_quic.d.ts")
+}
+
+pub const UNSTABLE_FEATURE_NAME: &str = "quic";
+
+deno_core::extension!(
+ deno_quic,
+ // deps = [],
+ parameters = [ P: NetPermissions ],
+ ops = [
+ op_quic_listen,
+ op_quic_accept,
+ op_quic_connect
,
+ op_quic_accept_bi,
+ op_quic_accept_uni,
+ op_quic_open_bi,
+ op_quic_open_uni,
+ op_quic_open_datagrams,
+ op_quic_max_datagram_size,
+ op_quic_close_connection,
+ op_quic_close_endpoint,
+ op_quic_connection_closed,
+ op_quic_get_send_stream_priority,
+ op_quic_set_send_stream_priority,
+ ],
+ esm = ["01_quic.js"],
+ options = {
+ root_cert_store_provider: Option>,
+ unsafely_ignore_certificate_errors: Option>,
+ },
+ state = |state, options| {
+ state.put(DefaultTlsOptions {
+ root_cert_store_provider: options.root_cert_store_provider,
+ });
+ state.put(UnsafelyIgnoreCertificateErrors(
+ options.unsafely_ignore_certificate_errors,
+ ));
+ },
+);
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Addr {
+ pub hostname: String,
+ pub port: u16,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListenArgs {
+ cert: String,
+ key: String,
+ alpn_protocols: Option>,
+}
+
+struct EndpointResource(quinn::Endpoint);
+
+impl Resource for EndpointResource {
+ fn name(&self) -> Cow {
+ "quicListener".into()
+ }
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_listen(
+ state: Rc>,
+ #[serde] addr: Addr,
+ #[serde] args: ListenArgs,
+) -> Result<(ResourceId, Addr), AnyError>
+where
+ NP: NetPermissions + 'static,
+{
+ state
+ .borrow_mut()
+ .borrow_mut::()
+ .check_net(&(&addr.hostname, Some(addr.port)), "Deno.connectQuic()")?;
+
+ let cert_chain = load_certs(&mut BufReader::new(args.cert.as_bytes()))?;
+ let key_der = load_private_keys(args.key.as_bytes())?.remove(0);
+
+ let addr = resolve_addr(&addr.hostname, addr.port)
+ .await?
+ .next()
+ .ok_or_else(|| generic_error("No resolved address found"))?;
+
+ let mut crypto = rustls::ServerConfig::builder()
+ .with_safe_defaults()
+ .with_no_client_auth()
+ .with_single_cert(cert_chain, key_der)?;
+ if let Some(alpn_protocols) = args.alpn_protocols {
+ crypto.alpn_protocols = alpn_protocols
+ .into_iter()
+ .map(|alpn| alpn.into_bytes())
+ .collect();
+ }
+ let config = quinn::ServerConfig::with_crypto(Arc::new(crypto));
+ let endpoint = quinn::Endpoint::server(config, addr)?;
+
+ let addr = endpoint.local_addr()?;
+ let addr = Addr {
+ hostname: format!("{}", addr.ip()),
+ port: addr.port(),
+ };
+
+ let rid = state
+ .borrow_mut()
+ .resource_table
+ .add(EndpointResource(endpoint));
+ Ok((rid, addr))
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct CloseInfo {
+ close_code: u64,
+ reason: String,
+}
+
+#[op2]
+#[serde]
+fn op_quic_close_endpoint(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+ #[serde] info: CloseInfo,
+) -> Result<(), AnyError> {
+ let endpoint = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ endpoint.close(
+ quinn::VarInt::from_u64(info.close_code)?,
+ info.reason.as_bytes(),
+ );
+ Ok(())
+}
+
+struct ConnectionResource(quinn::Connection);
+
+impl Resource for ConnectionResource {
+ fn name(&self) -> Cow {
+ "quicConnection".into()
+ }
+
+ fn read(self: Rc, _limit: usize) -> AsyncResult {
+ Box::pin(async move {
+ let data = self.0.read_datagram().await?;
+ Ok(BufView::from(data))
+ })
+ }
+
+ fn write(self: Rc, view: BufView) -> AsyncResult {
+ Box::pin(async move {
+ let len = view.len();
+ self.0.send_datagram(view.into())?;
+ Ok(WriteOutcome::Full { nwritten: len })
+ })
+ }
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_accept(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result)>, AnyError> {
+ let endpoint = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ match endpoint.accept().await {
+ Some(connecting) => {
+ let conn = connecting.await?;
+ let protocol = conn
+ .handshake_data()
+ .and_then(|h| h.downcast::().ok())
+ .and_then(|h| h.protocol)
+ .map(|p| String::from_utf8_lossy(&p).into_owned());
+ let rid = state
+ .borrow_mut()
+ .resource_table
+ .add(ConnectionResource(conn));
+ Ok(Some((rid, protocol)))
+ }
+ None => Ok(None),
+ }
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConnectArgs {
+ ca_certs: Vec,
+ cert_chain: Option,
+ private_key: Option,
+ alpn_protocols: Option>,
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_connect(
+ state: Rc>,
+ #[serde] addr: Addr,
+ #[serde] args: ConnectArgs,
+) -> Result<(ResourceId, Option), AnyError>
+where
+ NP: NetPermissions + 'static,
+{
+ state
+ .borrow_mut()
+ .borrow_mut::()
+ .check_net(&(&addr.hostname, Some(addr.port)), "Deno.connectQuic()")?;
+
+ let sock_addr = resolve_addr(&addr.hostname, addr.port)
+ .await?
+ .next()
+ .ok_or_else(|| generic_error("No resolved address found"))?;
+
+ let root_cert_store = state
+ .borrow()
+ .borrow::()
+ .root_cert_store()?;
+
+ let unsafely_ignore_certificate_errors = state
+ .borrow()
+ .try_borrow::()
+ .and_then(|it| it.0.clone());
+
+ let ca_certs = args
+ .ca_certs
+ .into_iter()
+ .map(|s| s.into_bytes())
+ .collect::>();
+
+ let cert_chain_and_key =
+ if args.cert_chain.is_some() || args.private_key.is_some() {
+ let cert_chain = args
+ .cert_chain
+ .ok_or_else(|| type_error("No certificate chain provided"))?;
+ let private_key = args
+ .private_key
+ .ok_or_else(|| type_error("No private key provided"))?;
+ Some((cert_chain, private_key))
+ } else {
+ None
+ };
+
+ let mut tls_config = create_client_config(
+ root_cert_store,
+ ca_certs,
+ unsafely_ignore_certificate_errors,
+ cert_chain_and_key,
+ SocketUse::GeneralSsl,
+ )?;
+
+ if let Some(alpn_protocols) = args.alpn_protocols {
+ tls_config.alpn_protocols =
+ alpn_protocols.into_iter().map(|s| s.into_bytes()).collect();
+ }
+
+ let client_config = quinn::ClientConfig::new(Arc::new(tls_config));
+
+ let endpoint = quinn::Endpoint::client("[::]:0".parse()?)?;
+ let conn = endpoint
+ .connect_with(client_config, sock_addr, &addr.hostname)?
+ .await?;
+
+ let protocol = conn
+ .handshake_data()
+ .and_then(|h| h.downcast::().ok())
+ .and_then(|h| h.protocol)
+ .map(|p| String::from_utf8_lossy(&p).into_owned());
+
+ let rid = state
+ .borrow_mut()
+ .resource_table
+ .add(ConnectionResource(conn));
+ Ok((rid, protocol))
+}
+
+#[op2]
+#[serde]
+fn op_quic_close_connection(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+ #[serde] info: CloseInfo,
+) -> Result<(), AnyError> {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ conn.close(
+ quinn::VarInt::from_u64(info.close_code)?,
+ info.reason.as_bytes(),
+ );
+ Ok(())
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_connection_closed(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ let e = conn.closed().await;
+ match e {
+ quinn::ConnectionError::LocallyClosed => Ok(CloseInfo {
+ close_code: 0,
+ reason: "".into(),
+ }),
+ quinn::ConnectionError::ApplicationClosed(i) => Ok(CloseInfo {
+ close_code: i.error_code.into(),
+ reason: String::from_utf8_lossy(&i.reason).into_owned(),
+ }),
+ e => Err(e.into()),
+ }
+}
+
+struct SendStreamResource(AsyncRefCell);
+
+impl SendStreamResource {
+ fn new(stream: quinn::SendStream) -> Self {
+ Self(AsyncRefCell::new(stream))
+ }
+}
+
+impl Resource for SendStreamResource {
+ fn name(&self) -> Cow {
+ "quicSendStream".into()
+ }
+
+ fn write(self: Rc, view: BufView) -> AsyncResult {
+ Box::pin(async move {
+ let mut r = RcRef::map(self, |r| &r.0).borrow_mut().await;
+ let nwritten = r.write(&view).await?;
+ Ok(WriteOutcome::Partial { nwritten, view })
+ })
+ }
+}
+
+struct RecvStreamResource(AsyncRefCell);
+
+impl RecvStreamResource {
+ fn new(stream: quinn::RecvStream) -> Self {
+ Self(AsyncRefCell::new(stream))
+ }
+}
+
+impl Resource for RecvStreamResource {
+ fn name(&self) -> Cow {
+ "quicReceiveStream".into()
+ }
+
+ fn read(self: Rc, limit: usize) -> AsyncResult {
+ Box::pin(async move {
+ let mut r = RcRef::map(self, |r| &r.0).borrow_mut().await;
+ let mut data = vec![0; limit];
+ let nread = r.read(&mut data).await?.unwrap_or(0);
+ data.truncate(nread);
+ Ok(BufView::from(data))
+ })
+ }
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_accept_bi(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result, AnyError> {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ match conn.accept_bi().await {
+ Ok((tx, rx)) => {
+ let tx_rid = state
+ .borrow_mut()
+ .resource_table
+ .add(SendStreamResource::new(tx));
+ let rx_rid = state
+ .borrow_mut()
+ .resource_table
+ .add(RecvStreamResource::new(rx));
+ Ok(Some((tx_rid, rx_rid)))
+ }
+ Err(e) => match e {
+ quinn::ConnectionError::LocallyClosed => Ok(None),
+ quinn::ConnectionError::ApplicationClosed(..) => Ok(None),
+ _ => Err(e.into()),
+ },
+ }
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_open_bi(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result<(ResourceId, ResourceId), AnyError> {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ let (tx, rx) = conn.open_bi().await?;
+ let tx_rid = state
+ .borrow_mut()
+ .resource_table
+ .add(SendStreamResource::new(tx));
+ let rx_rid = state
+ .borrow_mut()
+ .resource_table
+ .add(RecvStreamResource::new(rx));
+ Ok((tx_rid, rx_rid))
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_accept_uni(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result, AnyError> {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ match conn.accept_uni().await {
+ Ok(rx) => {
+ let rid = state
+ .borrow_mut()
+ .resource_table
+ .add(RecvStreamResource::new(rx));
+ Ok(Some(rid))
+ }
+ Err(e) => match e {
+ quinn::ConnectionError::LocallyClosed => Ok(None),
+ quinn::ConnectionError::ApplicationClosed(..) => Ok(None),
+ _ => Err(e.into()),
+ },
+ }
+}
+
+#[op2(async)]
+#[serde]
+async fn op_quic_open_uni(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+ let tx = conn.open_uni().await?;
+ let rid = state
+ .borrow_mut()
+ .resource_table
+ .add(SendStreamResource::new(tx));
+ Ok(rid)
+}
+
+#[op2]
+#[serde]
+fn op_quic_open_datagrams(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result<(ResourceId, ResourceId), AnyError> {
+ let conn = {
+ state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?
+ .0
+ .clone()
+ };
+
+ let rid1 = state
+ .borrow_mut()
+ .resource_table
+ .add(ConnectionResource(conn.clone()));
+ let rid2 = state
+ .borrow_mut()
+ .resource_table
+ .add(ConnectionResource(conn));
+
+ Ok((rid1, rid2))
+}
+
+#[op2]
+#[serde]
+fn op_quic_max_datagram_size(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result {
+ let resource = state
+ .borrow_mut()
+ .resource_table
+ .get::(rid)?;
+ Ok(resource.0.max_datagram_size().unwrap_or(0))
+}
+
+#[op2]
+#[serde]
+fn op_quic_get_send_stream_priority(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+) -> Result {
+ let resource = state
+ .borrow()
+ .resource_table
+ .get::(rid)?;
+ let r = RcRef::map(resource, |r| &r.0).try_borrow();
+ match r {
+ Some(s) => Ok(s.priority()? as _),
+ None => Err(generic_error("Unable to get priority")),
+ }
+}
+
+#[op2]
+#[serde]
+fn op_quic_set_send_stream_priority(
+ state: Rc>,
+ #[smi] rid: ResourceId,
+ priority: i32,
+) -> Result<(), AnyError> {
+ let resource = state
+ .borrow()
+ .resource_table
+ .get::(rid)?;
+ let r = RcRef::map(resource, |r| &r.0).try_borrow();
+ match r {
+ Some(s) => {
+ s.set_priority(priority)?;
+ Ok(())
+ }
+ None => Err(generic_error("Unable to set priority")),
+ }
+}
diff --git a/ext/web/06_streams.js b/ext/web/06_streams.js
index 976f623470d47e..480ab74a8775f4 100644
--- a/ext/web/06_streams.js
+++ b/ext/web/06_streams.js
@@ -915,8 +915,8 @@ const _original = Symbol("[[original]]");
* @param {boolean=} autoClose If the resource should be auto-closed when the stream closes. Defaults to true.
* @returns {ReadableStream}
*/
-function readableStreamForRid(rid, autoClose = true) {
- const stream = new ReadableStream(_brand);
+function readableStreamForRid(rid, autoClose = true, Super) {
+ const stream = new (Super ?? ReadableStream)(_brand);
stream[_resourceBacking] = { rid, autoClose };
const tryClose = () => {
@@ -1137,8 +1137,8 @@ async function readableStreamCollectIntoUint8Array(stream) {
* @param {boolean=} autoClose If the resource should be auto-closed when the stream closes. Defaults to true.
* @returns {ReadableStream}
*/
-function writableStreamForRid(rid, autoClose = true) {
- const stream = new WritableStream(_brand);
+function writableStreamForRid(rid, autoClose = true, Super) {
+ const stream = new (Super ?? WritableStream)(_brand);
stream[_resourceBacking] = { rid, autoClose };
const tryClose = () => {
diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml
index 18bad2d07856ae..ce4ef54155bf38 100644
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -54,6 +54,7 @@ deno_io.workspace = true
deno_net.workspace = true
deno_node.workspace = true
deno_kv.workspace = true
+deno_quic.workspace = true
deno_tls.workspace = true
deno_url.workspace = true
deno_web.workspace = true
@@ -86,6 +87,7 @@ deno_kv.workspace = true
deno_napi.workspace = true
deno_net.workspace = true
deno_node.workspace = true
+deno_quic.workspace = true
deno_tls.workspace = true
deno_url.workspace = true
deno_web.workspace = true
diff --git a/runtime/js/90_deno_ns.js b/runtime/js/90_deno_ns.js
index 97b4a9531f8651..8fd0d0c4e67e8a 100644
--- a/runtime/js/90_deno_ns.js
+++ b/runtime/js/90_deno_ns.js
@@ -25,6 +25,7 @@ import * as fsEvents from "ext:runtime/40_fs_events.js";
import * as process from "ext:runtime/40_process.js";
import * as signals from "ext:runtime/40_signals.js";
import * as tty from "ext:runtime/40_tty.js";
+import * as quic from "ext:deno_quic/01_quic.js";
// TODO(bartlomieju): this is funky we have two `http` imports
import * as httpRuntime from "ext:runtime/40_http.js";
import * as kv from "ext:deno_kv/01_db.ts";
@@ -171,6 +172,7 @@ const unstableIds = {
unsafeProto: 9,
webgpu: 10,
workerOptions: 11,
+ quic: 12,
};
const denoNsUnstableById = {};
@@ -226,6 +228,17 @@ denoNsUnstableById[unstableIds.net] = {
// denoNsUnstableById[unstableIds.workerOptions] = {}
+denoNsUnstableById[unstableIds.quic] = {
+ connectQuic: quic.connectQuic,
+ listenQuic: quic.listenQuic,
+ QuicBidirectionalStream: quic.QuicBidirectionalStream,
+ QuicDatagramDuplexStream: quic.QuicDatagramDuplexStream,
+ QuicConn: quic.QuicConn,
+ QuicListener: quic.QuicListener,
+ QuicReceiveStream: quic.QuicReceiveStream,
+ QuicSendStream: quic.QuicSendStream,
+};
+
// when editing this list, also update unstableDenoProps in cli/tsc/99_main_compiler.js
const denoNsUnstable = {
listenDatagram: net.createListenDatagram(
@@ -253,6 +266,14 @@ const denoNsUnstable = {
KvU64: kv.KvU64,
KvListIterator: kv.KvListIterator,
cron: cron.cron,
+ connectQuic: quic.connectQuic,
+ listenQuic: quic.listenQuic,
+ QuicBidirectionalStream: quic.QuicBidirectionalStream,
+ QuicDatagramDuplexStream: quic.QuicDatagramDuplexStream,
+ QuicConn: quic.QuicConn,
+ QuicListener: quic.QuicListener,
+ QuicReceiveStream: quic.QuicReceiveStream,
+ QuicSendStream: quic.QuicSendStream,
};
export { denoNs, denoNsUnstable, denoNsUnstableById, unstableIds };
diff --git a/runtime/lib.rs b/runtime/lib.rs
index dbdce7850a48e7..160fa69f5f233b 100644
--- a/runtime/lib.rs
+++ b/runtime/lib.rs
@@ -15,6 +15,7 @@ pub use deno_kv;
pub use deno_napi;
pub use deno_net;
pub use deno_node;
+pub use deno_quic;
pub use deno_tls;
pub use deno_url;
pub use deno_web;
diff --git a/runtime/shared.rs b/runtime/shared.rs
index 1f24fec0bb937b..f1796f72fbe444 100644
--- a/runtime/shared.rs
+++ b/runtime/shared.rs
@@ -30,7 +30,8 @@ extension!(runtime,
deno_napi,
deno_http,
deno_io,
- deno_fs
+ deno_fs,
+ deno_quic
],
esm_entry_point = "ext:runtime/90_deno_ns.js",
esm = [
diff --git a/runtime/snapshot.rs b/runtime/snapshot.rs
index a50f0773abfe72..eb5708d358b61d 100644
--- a/runtime/snapshot.rs
+++ b/runtime/snapshot.rs
@@ -226,6 +226,7 @@ pub fn create_runtime_snapshot(
),
deno_ffi::deno_ffi::init_ops_and_esm::(),
deno_net::deno_net::init_ops_and_esm::(None, None),
+ deno_quic::deno_quic::init_ops_and_esm::(None, None),
deno_tls::deno_tls::init_ops_and_esm(),
deno_kv::deno_kv::init_ops_and_esm(deno_kv::sqlite::SqliteDbHandler::<
Permissions,
diff --git a/runtime/worker.rs b/runtime/worker.rs
index 2cb1ab4915cce0..ec0d18e6cc33e5 100644
--- a/runtime/worker.rs
+++ b/runtime/worker.rs
@@ -377,6 +377,10 @@ impl MainWorker {
options.root_cert_store_provider.clone(),
options.unsafely_ignore_certificate_errors.clone(),
),
+ deno_quic::deno_quic::init_ops_and_esm::(
+ options.root_cert_store_provider.clone(),
+ options.unsafely_ignore_certificate_errors.clone(),
+ ),
deno_tls::deno_tls::init_ops_and_esm(),
deno_kv::deno_kv::init_ops_and_esm(
MultiBackendDbHandler::remote_or_sqlite::(
diff --git a/tools/core_import_map.json b/tools/core_import_map.json
index 8122a2c84d35e1..edffd61df3e562 100644
--- a/tools/core_import_map.json
+++ b/tools/core_import_map.json
@@ -20,6 +20,7 @@
"ext:deno_kv/01_db.ts": "../ext/kv/01_db.ts",
"ext:deno_net/01_net.js": "../ext/net/01_net.js",
"ext:deno_net/02_tls.js": "../ext/net/02_tls.js",
+ "ext:deno_quic/01_net.js": "../ext/quic/01_quic.js",
"ext:deno_node/_events.d.ts": "../ext/node/polyfills/_events.d.ts",
"ext:deno_node/_fs/_fs_close.ts": "../ext/node/polyfills/_fs/_fs_close.ts",
"ext:deno_node/_fs/_fs_common.ts": "../ext/node/polyfills/_fs/_fs_common.ts",