diff --git a/cli/build.rs b/cli/build.rs
index 22fb152225..7d131de86d 100644
--- a/cli/build.rs
+++ b/cli/build.rs
@@ -69,10 +69,6 @@ fn create_compiler_snapshot(
deno_broadcast_channel::get_declaration(),
);
op_crate_libs.insert("deno.net", deno_net::get_declaration());
- op_crate_libs
- .insert("deno.net_unstable", deno_net::get_unstable_declaration());
- op_crate_libs
- .insert("deno.http_unstable", deno_http::get_unstable_declaration());
// ensure we invalidate the build properly.
for (_, path) in op_crate_libs.iter() {
@@ -320,14 +316,6 @@ fn main() {
"cargo:rustc-env=DENO_NET_LIB_PATH={}",
deno_net::get_declaration().display()
);
- println!(
- "cargo:rustc-env=DENO_NET_UNSTABLE_LIB_PATH={}",
- deno_net::get_unstable_declaration().display()
- );
- println!(
- "cargo:rustc-env=DENO_HTTP_UNSTABLE_LIB_PATH={}",
- deno_http::get_unstable_declaration().display()
- );
println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
println!("cargo:rustc-env=PROFILE={}", env::var("PROFILE").unwrap());
diff --git a/cli/dts/lib.deno.unstable.d.ts b/cli/dts/lib.deno.unstable.d.ts
index ead4609c6d..3ee628a8b6 100644
--- a/cli/dts/lib.deno.unstable.d.ts
+++ b/cli/dts/lib.deno.unstable.d.ts
@@ -2,8 +2,6 @@
///
///
-///
-///
declare namespace Deno {
/**
@@ -1094,6 +1092,305 @@ declare namespace Deno {
write?: "inherit" | boolean | Array;
};
}
+
+ export interface WebSocketUpgrade {
+ response: Response;
+ socket: WebSocket;
+ }
+
+ export interface UpgradeWebSocketOptions {
+ protocol?: string;
+ }
+
+ /** **UNSTABLE**: new API, yet to be vetted.
+ *
+ * Used to upgrade an incoming HTTP request to a WebSocket.
+ *
+ * Given a request, returns a pair of WebSocket and Response. The original
+ * request must be responded to with the returned response for the websocket
+ * upgrade to be successful.
+ *
+ * ```ts
+ * const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
+ * const httpConn = Deno.serveHttp(conn);
+ * const e = await httpConn.nextRequest();
+ * if (e) {
+ * const { socket, response } = Deno.upgradeWebSocket(e.request);
+ * socket.onopen = () => {
+ * socket.send("Hello World!");
+ * };
+ * socket.onmessage = (e) => {
+ * console.log(e.data);
+ * socket.close();
+ * };
+ * socket.onclose = () => console.log("WebSocket has been closed.");
+ * socket.onerror = (e) => console.error("WebSocket error:", e);
+ * e.respondWith(response);
+ * }
+ * ```
+ *
+ * If the request body is disturbed (read from) before the upgrade is
+ * completed, upgrading fails.
+ *
+ * This operation does not yet consume the request or open the websocket. This
+ * only happens once the returned response has been passed to `respondWith`.
+ */
+ export function upgradeWebSocket(
+ request: Request,
+ options?: UpgradeWebSocketOptions,
+ ): WebSocketUpgrade;
+
+ /** The type of the resource record.
+ * Only the listed types are supported currently. */
+ export type RecordType =
+ | "A"
+ | "AAAA"
+ | "ANAME"
+ | "CNAME"
+ | "MX"
+ | "PTR"
+ | "SRV"
+ | "TXT";
+
+ export interface ResolveDnsOptions {
+ /** The name server to be used for lookups.
+ * If not specified, defaults to the system configuration e.g. `/etc/resolv.conf` on Unix. */
+ nameServer?: {
+ /** The IP address of the name server */
+ ipAddr: string;
+ /** The port number the query will be sent to.
+ * If not specified, defaults to 53. */
+ port?: number;
+ };
+ }
+
+ /** If `resolveDns` is called with "MX" record type specified, it will return an array of this interface. */
+ export interface MXRecord {
+ preference: number;
+ exchange: string;
+ }
+
+ /** If `resolveDns` is called with "SRV" record type specified, it will return an array of this interface. */
+ export interface SRVRecord {
+ priority: number;
+ weight: number;
+ port: number;
+ target: string;
+ }
+
+ export function resolveDns(
+ query: string,
+ recordType: "A" | "AAAA" | "ANAME" | "CNAME" | "PTR",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ export function resolveDns(
+ query: string,
+ recordType: "MX",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ export function resolveDns(
+ query: string,
+ recordType: "SRV",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ export function resolveDns(
+ query: string,
+ recordType: "TXT",
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /** ** UNSTABLE**: new API, yet to be vetted.
+ *
+ * Performs DNS resolution against the given query, returning resolved records.
+ * Fails in the cases such as:
+ * - the query is in invalid format
+ * - the options have an invalid parameter, e.g. `nameServer.port` is beyond the range of 16-bit unsigned integer
+ * - timed out
+ *
+ * ```ts
+ * const a = await Deno.resolveDns("example.com", "A");
+ *
+ * const aaaa = await Deno.resolveDns("example.com", "AAAA", {
+ * nameServer: { ipAddr: "8.8.8.8", port: 1234 },
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ */
+ export function resolveDns(
+ query: string,
+ recordType: RecordType,
+ options?: ResolveDnsOptions,
+ ): Promise;
+
+ /** **UNSTABLE**: new API, yet to be vetted.
+ *
+ * A generic transport listener for message-oriented protocols. */
+ export interface DatagramConn extends AsyncIterable<[Uint8Array, Addr]> {
+ /** **UNSTABLE**: new API, yet to be vetted.
+ *
+ * Waits for and resolves to the next message to the `UDPConn`. */
+ receive(p?: Uint8Array): Promise<[Uint8Array, Addr]>;
+ /** UNSTABLE: new API, yet to be vetted.
+ *
+ * Sends a message to the target. */
+ send(p: Uint8Array, addr: Addr): Promise;
+ /** UNSTABLE: new API, yet to be vetted.
+ *
+ * Close closes the socket. Any pending message promises will be rejected
+ * with errors. */
+ close(): void;
+ /** Return the address of the `UDPConn`. */
+ readonly addr: Addr;
+ [Symbol.asyncIterator](): AsyncIterableIterator<[Uint8Array, Addr]>;
+ }
+
+ export interface UnixListenOptions {
+ /** A Path to the Unix Socket. */
+ path: string;
+ }
+
+ /** **UNSTABLE**: new API, yet to be vetted.
+ *
+ * Listen announces on the local transport address.
+ *
+ * ```ts
+ * const listener = Deno.listen({ path: "/foo/bar.sock", transport: "unix" })
+ * ```
+ *
+ * Requires `allow-read` and `allow-write` permission. */
+ export function listen(
+ options: UnixListenOptions & { transport: "unix" },
+ ): Listener;
+
+ /** **UNSTABLE**: new API, yet to be vetted
+ *
+ * Listen announces on the local transport address.
+ *
+ * ```ts
+ * const listener1 = Deno.listenDatagram({
+ * port: 80,
+ * transport: "udp"
+ * });
+ * const listener2 = Deno.listenDatagram({
+ * hostname: "golang.org",
+ * port: 80,
+ * transport: "udp"
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission. */
+ export function listenDatagram(
+ options: ListenOptions & { transport: "udp" },
+ ): DatagramConn;
+
+ /** **UNSTABLE**: new API, yet to be vetted
+ *
+ * Listen announces on the local transport address.
+ *
+ * ```ts
+ * const listener = Deno.listenDatagram({
+ * path: "/foo/bar.sock",
+ * transport: "unixpacket"
+ * });
+ * ```
+ *
+ * Requires `allow-read` and `allow-write` permission. */
+ export function listenDatagram(
+ options: UnixListenOptions & { transport: "unixpacket" },
+ ): DatagramConn;
+
+ export interface UnixConnectOptions {
+ transport: "unix";
+ path: string;
+ }
+
+ /** **UNSTABLE**: The unix socket transport is unstable as a new API yet to
+ * be vetted. The TCP transport is considered stable.
+ *
+ * Connects to the hostname (default is "127.0.0.1") and port on the named
+ * transport (default is "tcp"), and resolves to the connection (`Conn`).
+ *
+ * ```ts
+ * const conn1 = await Deno.connect({ port: 80 });
+ * const conn2 = await Deno.connect({ hostname: "192.0.2.1", port: 80 });
+ * const conn3 = await Deno.connect({ hostname: "[2001:db8::1]", port: 80 });
+ * const conn4 = await Deno.connect({ hostname: "golang.org", port: 80, transport: "tcp" });
+ * const conn5 = await Deno.connect({ path: "/foo/bar.sock", transport: "unix" });
+ * ```
+ *
+ * Requires `allow-net` permission for "tcp" and `allow-read` for "unix". */
+ export function connect(
+ options: ConnectOptions | UnixConnectOptions,
+ ): Promise;
+
+ export interface ConnectTlsClientCertOptions {
+ /** PEM formatted client certificate chain. */
+ certChain: string;
+ /** PEM formatted (RSA or PKCS8) private key of client certificate. */
+ privateKey: string;
+ }
+
+ /** **UNSTABLE** New API, yet to be vetted.
+ *
+ * Create a TLS connection with an attached client certificate.
+ *
+ * ```ts
+ * const conn = await Deno.connectTls({
+ * hostname: "deno.land",
+ * port: 443,
+ * certChain: "---- BEGIN CERTIFICATE ----\n ...",
+ * privateKey: "---- BEGIN PRIVATE KEY ----\n ...",
+ * });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ */
+ export function connectTls(
+ options: ConnectTlsOptions & ConnectTlsClientCertOptions,
+ ): Promise;
+
+ export interface StartTlsOptions {
+ /** A literal IP address or host name that can be resolved to an IP address.
+ * If not specified, defaults to `127.0.0.1`. */
+ hostname?: string;
+ /** Server certificate file. */
+ certFile?: string;
+ }
+
+ /** **UNSTABLE**: new API, yet to be vetted.
+ *
+ * Start TLS handshake from an existing connection using
+ * an optional cert file, hostname (default is "127.0.0.1"). The
+ * cert file is optional and if not included Mozilla's root certificates will
+ * be used (see also https://github.com/ctz/webpki-roots for specifics)
+ * Using this function requires that the other end of the connection is
+ * prepared for TLS handshake.
+ *
+ * ```ts
+ * const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
+ * const tlsConn = await Deno.startTls(conn, { certFile: "./certs/my_custom_root_CA.pem", hostname: "localhost" });
+ * ```
+ *
+ * Requires `allow-net` permission.
+ */
+ export function startTls(
+ conn: Conn,
+ options?: StartTlsOptions,
+ ): Promise;
+
+ export interface ListenTlsOptions {
+ /** **UNSTABLE**: new API, yet to be vetted.
+ *
+ * Application-Layer Protocol Negotiation (ALPN) protocols to announce to
+ * the client. If not specified, no ALPN extension will be included in the
+ * TLS handshake.
+ */
+ alpnProtocols?: string[];
+ }
}
declare function fetch(
diff --git a/cli/main.rs b/cli/main.rs
index 8de1f1fc51..beb54cd233 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -358,8 +358,6 @@ pub fn get_types(unstable: bool) -> String {
if unstable {
types.push(crate::tsc::UNSTABLE_NS_LIB);
- types.push(crate::tsc::DENO_NET_UNSTABLE_LIB);
- types.push(crate::tsc::DENO_HTTP_UNSTABLE_LIB);
}
types.join("\n")
diff --git a/cli/tsc.rs b/cli/tsc.rs
index 57bbeeca38..144ff8021f 100644
--- a/cli/tsc.rs
+++ b/cli/tsc.rs
@@ -45,10 +45,6 @@ pub static DENO_CRYPTO_LIB: &str = include_str!(env!("DENO_CRYPTO_LIB_PATH"));
pub static DENO_BROADCAST_CHANNEL_LIB: &str =
include_str!(env!("DENO_BROADCAST_CHANNEL_LIB_PATH"));
pub static DENO_NET_LIB: &str = include_str!(env!("DENO_NET_LIB_PATH"));
-pub static DENO_NET_UNSTABLE_LIB: &str =
- include_str!(env!("DENO_NET_UNSTABLE_LIB_PATH"));
-pub static DENO_HTTP_UNSTABLE_LIB: &str =
- include_str!(env!("DENO_HTTP_UNSTABLE_LIB_PATH"));
pub static SHARED_GLOBALS_LIB: &str =
include_str!("dts/lib.deno.shared_globals.d.ts");
pub static WINDOW_LIB: &str = include_str!("dts/lib.deno.window.d.ts");
diff --git a/ext/http/README.md b/ext/http/README.md
deleted file mode 100644
index ab557017a5..0000000000
--- a/ext/http/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# deno_http
-
-This crate implements server-side HTTP based on primitives from the
-[Fetch API](https://fetch.spec.whatwg.org/).
diff --git a/ext/http/lib.deno_http.unstable.d.ts b/ext/http/lib.deno_http.unstable.d.ts
deleted file mode 100644
index 5c5bf78df9..0000000000
--- a/ext/http/lib.deno_http.unstable.d.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-
-///
-///
-
-declare namespace Deno {
- export interface WebSocketUpgrade {
- response: Response;
- socket: WebSocket;
- }
-
- export interface UpgradeWebSocketOptions {
- protocol?: string;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Used to upgrade an incoming HTTP request to a WebSocket.
- *
- * Given a request, returns a pair of WebSocket and Response. The original
- * request must be responded to with the returned response for the websocket
- * upgrade to be successful.
- *
- * ```ts
- * const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
- * const httpConn = Deno.serveHttp(conn);
- * const e = await httpConn.nextRequest();
- * if (e) {
- * const { socket, response } = Deno.upgradeWebSocket(e.request);
- * socket.onopen = () => {
- * socket.send("Hello World!");
- * };
- * socket.onmessage = (e) => {
- * console.log(e.data);
- * socket.close();
- * };
- * socket.onclose = () => console.log("WebSocket has been closed.");
- * socket.onerror = (e) => console.error("WebSocket error:", e.message);
- * e.respondWith(response);
- * }
- * ```
- *
- * If the request body is disturbed (read from) before the upgrade is
- * completed, upgrading fails.
- *
- * This operation does not yet consume the request or open the websocket. This
- * only happens once the returned response has been passed to `respondWith`.
- */
- export function upgradeWebSocket(
- request: Request,
- options?: UpgradeWebSocketOptions,
- ): WebSocketUpgrade;
-}
diff --git a/ext/http/lib.rs b/ext/http/lib.rs
index 8221a6b0d8..ba6d73d5c0 100644
--- a/ext/http/lib.rs
+++ b/ext/http/lib.rs
@@ -34,7 +34,6 @@ use std::borrow::Cow;
use std::cell::RefCell;
use std::future::Future;
use std::net::SocketAddr;
-use std::path::PathBuf;
use std::pin::Pin;
use std::rc::Rc;
use std::task::Context;
@@ -45,10 +44,6 @@ use tokio::io::AsyncWrite;
use tokio::sync::oneshot;
use tokio_util::io::StreamReader;
-pub fn get_unstable_declaration() -> PathBuf {
- PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_http.unstable.d.ts")
-}
-
pub fn init() -> Extension {
Extension::builder()
.js(include_js_files!(
diff --git a/ext/net/lib.deno_net.unstable.d.ts b/ext/net/lib.deno_net.unstable.d.ts
deleted file mode 100644
index 145f232c09..0000000000
--- a/ext/net/lib.deno_net.unstable.d.ts
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-
-///
-///
-
-declare namespace Deno {
- /** The type of the resource record.
- * Only the listed types are supported currently. */
- export type RecordType =
- | "A"
- | "AAAA"
- | "ANAME"
- | "CNAME"
- | "MX"
- | "PTR"
- | "SRV"
- | "TXT";
-
- export interface ResolveDnsOptions {
- /** The name server to be used for lookups.
- * If not specified, defaults to the system configuration e.g. `/etc/resolv.conf` on Unix. */
- nameServer?: {
- /** The IP address of the name server */
- ipAddr: string;
- /** The port number the query will be sent to.
- * If not specified, defaults to 53. */
- port?: number;
- };
- }
-
- /** If `resolveDns` is called with "MX" record type specified, it will return an array of this interface. */
- export interface MXRecord {
- preference: number;
- exchange: string;
- }
-
- /** If `resolveDns` is called with "SRV" record type specified, it will return an array of this interface. */
- export interface SRVRecord {
- priority: number;
- weight: number;
- port: number;
- target: string;
- }
-
- export function resolveDns(
- query: string,
- recordType: "A" | "AAAA" | "ANAME" | "CNAME" | "PTR",
- options?: ResolveDnsOptions,
- ): Promise;
-
- export function resolveDns(
- query: string,
- recordType: "MX",
- options?: ResolveDnsOptions,
- ): Promise;
-
- export function resolveDns(
- query: string,
- recordType: "SRV",
- options?: ResolveDnsOptions,
- ): Promise;
-
- export function resolveDns(
- query: string,
- recordType: "TXT",
- options?: ResolveDnsOptions,
- ): Promise;
-
- /** ** UNSTABLE**: new API, yet to be vetted.
-*
-* Performs DNS resolution against the given query, returning resolved records.
-* Fails in the cases such as:
-* - the query is in invalid format
-* - the options have an invalid parameter, e.g. `nameServer.port` is beyond the range of 16-bit unsigned integer
-* - timed out
-*
-* ```ts
-* const a = await Deno.resolveDns("example.com", "A");
-*
-* const aaaa = await Deno.resolveDns("example.com", "AAAA", {
-* nameServer: { ipAddr: "8.8.8.8", port: 1234 },
-* });
-* ```
-*
-* Requires `allow-net` permission.
- */
- export function resolveDns(
- query: string,
- recordType: RecordType,
- options?: ResolveDnsOptions,
- ): Promise;
-
- /** **UNSTABLE**: new API, yet to be vetted.
-*
-* A generic transport listener for message-oriented protocols. */
- export interface DatagramConn extends AsyncIterable<[Uint8Array, Addr]> {
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Waits for and resolves to the next message to the `UDPConn`. */
- receive(p?: Uint8Array): Promise<[Uint8Array, Addr]>;
- /** UNSTABLE: new API, yet to be vetted.
- *
- * Sends a message to the target. */
- send(p: Uint8Array, addr: Addr): Promise;
- /** UNSTABLE: new API, yet to be vetted.
- *
- * Close closes the socket. Any pending message promises will be rejected
- * with errors. */
- close(): void;
- /** Return the address of the `UDPConn`. */
- readonly addr: Addr;
- [Symbol.asyncIterator](): AsyncIterableIterator<[Uint8Array, Addr]>;
- }
-
- export interface UnixListenOptions {
- /** A Path to the Unix Socket. */
- path: string;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
-*
-* Listen announces on the local transport address.
-*
-* ```ts
-* const listener = Deno.listen({ path: "/foo/bar.sock", transport: "unix" })
-* ```
-*
-* Requires `allow-read` and `allow-write` permission. */
- export function listen(
- options: UnixListenOptions & { transport: "unix" },
- ): Listener;
-
- /** **UNSTABLE**: new API, yet to be vetted
-*
-* Listen announces on the local transport address.
-*
-* ```ts
-* const listener1 = Deno.listenDatagram({
-* port: 80,
-* transport: "udp"
-* });
-* const listener2 = Deno.listenDatagram({
-* hostname: "golang.org",
-* port: 80,
-* transport: "udp"
-* });
-* ```
-*
-* Requires `allow-net` permission. */
- export function listenDatagram(
- options: ListenOptions & { transport: "udp" },
- ): DatagramConn;
-
- /** **UNSTABLE**: new API, yet to be vetted
-*
-* Listen announces on the local transport address.
-*
-* ```ts
-* const listener = Deno.listenDatagram({
-* path: "/foo/bar.sock",
-* transport: "unixpacket"
-* });
-* ```
-*
-* Requires `allow-read` and `allow-write` permission. */
- export function listenDatagram(
- options: UnixListenOptions & { transport: "unixpacket" },
- ): DatagramConn;
-
- export interface UnixConnectOptions {
- transport: "unix";
- path: string;
- }
-
- /** **UNSTABLE**: The unix socket transport is unstable as a new API yet to
-* be vetted. The TCP transport is considered stable.
-*
-* Connects to the hostname (default is "127.0.0.1") and port on the named
-* transport (default is "tcp"), and resolves to the connection (`Conn`).
-*
-* ```ts
-* const conn1 = await Deno.connect({ port: 80 });
-* const conn2 = await Deno.connect({ hostname: "192.0.2.1", port: 80 });
-* const conn3 = await Deno.connect({ hostname: "[2001:db8::1]", port: 80 });
-* const conn4 = await Deno.connect({ hostname: "golang.org", port: 80, transport: "tcp" });
-* const conn5 = await Deno.connect({ path: "/foo/bar.sock", transport: "unix" });
-* ```
-*
-* Requires `allow-net` permission for "tcp" and `allow-read` for "unix". */
- export function connect(
- options: ConnectOptions | UnixConnectOptions,
- ): Promise;
-
- export interface ConnectTlsClientCertOptions {
- /** PEM formatted client certificate chain. */
- certChain: string;
- /** PEM formatted (RSA or PKCS8) private key of client certificate. */
- privateKey: string;
- }
-
- /** **UNSTABLE** New API, yet to be vetted.
- *
- * Create a TLS connection with an attached client certificate.
- *
- * ```ts
- * const conn = await Deno.connectTls({
- * hostname: "deno.land",
- * port: 443,
- * certChain: "---- BEGIN CERTIFICATE ----\n ...",
- * privateKey: "---- BEGIN PRIVATE KEY ----\n ...",
- * });
- * ```
- *
- * Requires `allow-net` permission.
- */
- export function connectTls(
- options: ConnectTlsOptions & ConnectTlsClientCertOptions,
- ): Promise;
-
- export interface StartTlsOptions {
- /** A literal IP address or host name that can be resolved to an IP address.
- * If not specified, defaults to `127.0.0.1`. */
- hostname?: string;
- /** Server certificate file. */
- certFile?: string;
- }
-
- /** **UNSTABLE**: new API, yet to be vetted.
-*
-* Start TLS handshake from an existing connection using
-* an optional cert file, hostname (default is "127.0.0.1"). The
-* cert file is optional and if not included Mozilla's root certificates will
-* be used (see also https://github.com/ctz/webpki-roots for specifics)
-* Using this function requires that the other end of the connection is
-* prepared for TLS handshake.
-*
-* ```ts
-* const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
-* const tlsConn = await Deno.startTls(conn, { certFile: "./certs/my_custom_root_CA.pem", hostname: "localhost" });
-* ```
-*
-* Requires `allow-net` permission.
- */
- export function startTls(
- conn: Conn,
- options?: StartTlsOptions,
- ): Promise;
-
- export interface ListenTlsOptions {
- /** **UNSTABLE**: new API, yet to be vetted.
- *
- * Application-Layer Protocol Negotiation (ALPN) protocols to announce to
- * the client. If not specified, no ALPN extension will be included in the
- * TLS handshake.
- */
- alpnProtocols?: string[];
- }
-}
diff --git a/ext/net/lib.rs b/ext/net/lib.rs
index 3764433e3b..068a865eb2 100644
--- a/ext/net/lib.rs
+++ b/ext/net/lib.rs
@@ -85,10 +85,6 @@ pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_net.d.ts")
}
-pub fn get_unstable_declaration() -> PathBuf {
- PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_net.unstable.d.ts")
-}
-
#[derive(Clone)]
pub struct DefaultTlsOptions {
pub root_cert_store: Option,