@fkn/lib 0.3.1 → 0.3.3

package/index.js

@@ -6,7 +6,7 @@ import { Address4 as m, Address6 as h } from "ip-address";
 import "dns-packet";
 import "buffer";
 //#region src/lib/dom.ts
-var g = "http://localhost:1234", _ = globalThis?.document.querySelector(`iframe[src="${g}/api"]`), v = globalThis.document?.createElement("iframe");
+var g = "https://fkn.app", _ = globalThis?.document.querySelector(`iframe[src="${g}/api"]`), v = globalThis.document?.createElement("iframe");
 !_ && v && (v.src = `${g}/api`, v.style.display = "none", document.body.appendChild(v));
 var y = _ || v, b = y.contentWindow;
 if (!y.contentWindow) throw Error("Missing iframe content window");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fkn/lib",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",

package/api/dns/index.d.ts

@@ -1,7 +0,0 @@
-export * from './lookup';
-export declare const resolvers: {
-    readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
-        all?: T;
-        family: 0 | 4 | 6;
-    }) => Promise<T extends true ? import('./lookup').AddressLookupResult[] : import('./lookup').AddressLookupResult | undefined>;
-};

package/api/dns/lookup.d.ts

@@ -1,8 +0,0 @@
-export type AddressLookupResult = {
-    address: string;
-    family: 0 | 4 | 6;
-};
-export declare const dnsLookup: <T extends boolean = false>(hostname: string, options?: {
-    all?: T;
-    family: 0 | 4 | 6;
-}) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;

package/api/events.d.ts

@@ -1,7 +0,0 @@
-declare const _default: {
-    dispatchAll: <T = any>(type: string, value?: any) => Promise<T[]>;
-    dispatch: <T = any>(type: string, value?: any) => Promise<T>;
-    addEventListener: (type: string, listener: Function) => Map<string, Function[]>;
-    removeEventListener: (type: string, listener: Function) => Map<string, Function[]>;
-};
-export default _default;

package/api/index.d.ts

@@ -1,66 +0,0 @@
-declare const resolvers: {
-    readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
-        all?: T;
-        family: 0 | 4 | 6;
-    }) => Promise<T extends true ? import('./dns').AddressLookupResult[] : import('./dns').AddressLookupResult | undefined>;
-    readonly webVpnTcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
-        remoteAddress: string;
-        remotePort: number;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        remoteAddress: string;
-        remoteFamily: "IPv4" | "IPv6";
-        remotePort: number;
-        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
-        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
-        end: () => Promise<void>;
-        destroy: () => Promise<void>;
-        destroySoon: () => Promise<void>;
-        resetAndDestroy: () => Promise<void>;
-        setOption: (option: import('./webvpn/tcp').TcpSocketOption) => Promise<void>;
-    }>;
-    readonly webVpnTcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
-        localAddress: string;
-        localPort: number;
-        onConnection: (connection: import('./webvpn/tcp').TcpSocketResult) => void;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        close: () => Promise<void>;
-    }>;
-    readonly webVpnUdpSocket: ({ type, port, address }: {
-        type: "udp4" | "udp6";
-        port: number;
-        address: string;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        dataReadableStream: ReadableStream<{
-            data: ArrayBuffer;
-            size: number;
-            family: "IPv4" | "IPv6";
-            address: string;
-            port: number;
-        }>;
-        connect: ({ remoteAddress: _remoteAddress, remotePort }: {
-            remoteAddress: string;
-            remotePort: number;
-        }) => Promise<void>;
-        send: ({ message, address: _remoteAddress, port: remotePort }: {
-            message: ArrayBuffer;
-            address?: string;
-            port?: number;
-        }) => Promise<void>;
-        close: () => Promise<void>;
-        setOption: (option: import('./webvpn/udp').UdpSocketOption) => Promise<void>;
-    }>;
-    readonly proxyFetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
-        render?: boolean;
-    }) => Promise<Response>;
-};
-export type Resolvers = typeof resolvers;
-export {};

package/api/proxy/extension-proxy-fetch.d.ts

@@ -1,4 +0,0 @@
-declare const _default: (url: any, init: any, { package: pkg }?: {
-    package: undefined;
-}) => Promise<Response>;
-export default _default;

package/api/proxy/index.d.ts

@@ -1,7 +0,0 @@
-import { proxyFetch } from './proxy-fetch';
-export { proxyFetch };
-export declare const resolvers: {
-    readonly proxyFetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
-        render?: boolean;
-    }) => Promise<Response>;
-};

package/api/proxy/proxy-fetch.d.ts

@@ -1,5 +0,0 @@
-type FetchArgs = Parameters<typeof fetch>;
-export declare const proxyFetch: (input: FetchArgs[0], init?: FetchArgs[1] & {
-    render?: boolean;
-}) => Promise<Response>;
-export {};

package/api/utils/event-target.d.ts

@@ -1,7 +0,0 @@
-declare const _default: () => {
-    dispatchAll: <T = any>(type: string, value?: any) => Promise<T[]>;
-    dispatch: <T = any>(type: string, value?: any) => Promise<T>;
-    addEventListener: (type: string, listener: Function) => Map<string, Function[]>;
-    removeEventListener: (type: string, listener: Function) => Map<string, Function[]>;
-};
-export default _default;

package/api/utils/index.d.ts

@@ -1 +0,0 @@
-export { default as makeEventTarget } from './event-target';

package/api/webvpn/index.d.ts

@@ -1,60 +0,0 @@
-export { webVpnTcpSocket } from './tcp';
-export { webVpnTcpSocketListener } from './tcp-listener';
-export { webVpnUdpSocket } from './udp';
-export declare const resolvers: {
-    readonly webVpnTcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
-        remoteAddress: string;
-        remotePort: number;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        remoteAddress: string;
-        remoteFamily: "IPv4" | "IPv6";
-        remotePort: number;
-        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
-        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
-        end: () => Promise<void>;
-        destroy: () => Promise<void>;
-        destroySoon: () => Promise<void>;
-        resetAndDestroy: () => Promise<void>;
-        setOption: (option: import('./tcp').TcpSocketOption) => Promise<void>;
-    }>;
-    readonly webVpnTcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
-        localAddress: string;
-        localPort: number;
-        onConnection: (connection: import('./tcp').TcpSocketResult) => void;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        close: () => Promise<void>;
-    }>;
-    readonly webVpnUdpSocket: ({ type, port, address }: {
-        type: "udp4" | "udp6";
-        port: number;
-        address: string;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        dataReadableStream: ReadableStream<{
-            data: ArrayBuffer;
-            size: number;
-            family: "IPv4" | "IPv6";
-            address: string;
-            port: number;
-        }>;
-        connect: ({ remoteAddress: _remoteAddress, remotePort }: {
-            remoteAddress: string;
-            remotePort: number;
-        }) => Promise<void>;
-        send: ({ message, address: _remoteAddress, port: remotePort }: {
-            message: ArrayBuffer;
-            address?: string;
-            port?: number;
-        }) => Promise<void>;
-        close: () => Promise<void>;
-        setOption: (option: import('./udp').UdpSocketOption) => Promise<void>;
-    }>;
-};

package/api/webvpn/packets/metadata.d.ts

@@ -1,30 +0,0 @@
-import { ServerMetadataTcpSetOptionAckPacket, ServerMetadataTcpSocketConnectedPacket, ServerMetadataTcpSocketShutdownPacket } from './tcp';
-import { ServerMetadataTcpSocketListenerBoundPacket, ServerMetadataTcpSocketListenerUnboundPacket } from './tcp-listener';
-import { ServerMetadataUdpSetOptionAckPacket, ServerMetadataUdpSocketBoundPacket, ServerMetadataUdpSocketConnectedPacket, ServerMetadataUdpSocketUnboundPacket } from './udp';
-export declare const parseClientMetadataHeaderPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataHeaderPacket";
-    readonly offset: number;
-    readonly agentLength: number;
-    readonly agent: string;
-    readonly versionLength: number;
-    readonly version: string;
-};
-export type ClientMetadataHeaderPacket = Omit<ReturnType<typeof parseClientMetadataHeaderPacket>, 'offset'>;
-export declare const packClientMetadataHeaderPacket: (packet: Pick<ClientMetadataHeaderPacket, "agent" | "version">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataHeaderPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataHeaderPacket";
-    readonly offset: number;
-    readonly agentLength: number;
-    readonly agent: string;
-    readonly versionLength: number;
-    readonly version: string;
-};
-export type ServerMetadataHeaderPacket = ReturnType<typeof parseServerMetadataHeaderPacket>;
-export declare const packServerMetadataHeaderPacket: (packet: Pick<ServerMetadataHeaderPacket, "agent" | "version">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => ServerMetadataPacket;
-export type ServerMetadataPacket = ServerMetadataHeaderPacket | ServerMetadataTcpSocketConnectedPacket | ServerMetadataTcpSocketShutdownPacket | ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket | ServerMetadataUdpSocketBoundPacket | ServerMetadataUdpSocketUnboundPacket | ServerMetadataUdpSocketConnectedPacket | ServerMetadataTcpSetOptionAckPacket | ServerMetadataUdpSetOptionAckPacket;
-export declare const parseServerMetadataPackets: (buffer: ArrayBuffer) => {
-    packets: ServerMetadataPacket[];
-    remaining: ArrayBuffer;
-};
-export declare const createServerMetadataPacketTransformStream: () => TransformStream<Uint8Array<ArrayBufferLike>, ServerMetadataPacket>;

package/api/webvpn/packets/metadata.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/webvpn/packets/proptest.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/webvpn/packets/tcp-listener.d.ts

@@ -1,39 +0,0 @@
-export declare const parseClientMetadataTcpSocketListenerBindPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly offset: number;
-    readonly id: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly localPort: number;
-};
-export type ClientMetadataTcpSocketListenerBindPacket = ReturnType<typeof parseClientMetadataTcpSocketListenerBindPacket>;
-export declare const packClientMetadataTcpSocketListenerBindPacket: (packet: Omit<ClientMetadataTcpSocketListenerBindPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseClientMetadataTcpSocketListenerUnbindPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataTcpSocketListenerUnbindPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ClientMetadataTcpSocketListenerUnbindPacket = ReturnType<typeof parseClientMetadataTcpSocketListenerUnbindPacket>;
-export declare const packClientMetadataTcpSocketListenerUnbindPacket: (packet: Omit<ClientMetadataTcpSocketListenerUnbindPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSocketListenerBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketListenerBoundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly localPort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-export type ServerMetadataTcpSocketListenerBoundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerBoundPacket>;
-export declare const packServerMetadataTcpSocketListenerBoundPacket: (packet: Omit<ServerMetadataTcpSocketListenerBoundPacket, "_type" | "offset" | "errorLength">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSocketListenerUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketListenerUnboundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ServerMetadataTcpSocketListenerUnboundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerUnboundPacket>;
-export declare const packServerMetadataTcpSocketListenerUnboundPacket: (packet: Omit<ServerMetadataTcpSocketListenerUnboundPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export type ServerMetadataTcpSocketListenerPacket = ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket;

package/api/webvpn/packets/tcp-listener.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/webvpn/packets/tcp.d.ts

@@ -1,88 +0,0 @@
-export declare const parseClientMetadataTcpSocketConnectPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataTcpSocketConnectPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly remotePort: number;
-};
-export type ClientMetadataTcpSocketConnectPacket = ReturnType<typeof parseClientMetadataTcpSocketConnectPacket>;
-export declare const packClientMetadataTcpSocketConnectPacket: (packet: Omit<ClientMetadataTcpSocketConnectPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseClientMetadataTcpSocketTcpShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataTcpSocketTcpShutdownPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ClientMetadataTcpSocketTcpShutdownPacket = ReturnType<typeof parseClientMetadataTcpSocketTcpShutdownPacket>;
-export declare const packClientMetadataTcpSocketTcpShutdownPacket: (packet: Omit<ClientMetadataTcpSocketTcpShutdownPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSocketConnectedPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketConnectedPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly localPort: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly remotePort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-export type ServerMetadataTcpSocketConnectedPacket = ReturnType<typeof parseServerMetadataTcpSocketConnectedPacket>;
-export declare const packServerMetadataTcpSocketConnectedPacket: (packet: Omit<ServerMetadataTcpSocketConnectedPacket, "_type" | "offset" | "errorLength">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSocketShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketShutdownPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ServerMetadataTcpSocketShutdownPacket = ReturnType<typeof parseServerMetadataTcpSocketShutdownPacket>;
-export declare const packServerMetadataTcpSocketShutdownPacket: (packet: Omit<ServerMetadataTcpSocketShutdownPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export type ClientMetadataTcpSocketPacket = ClientMetadataTcpSocketConnectPacket | ClientMetadataTcpSocketTcpShutdownPacket;
-export declare const TCP_OPTION_NODELAY: 0;
-export declare const TCP_OPTION_TTL: 1;
-export declare const TCP_OPTION_KEEPALIVE: 2;
-export declare const TCP_OPTION_SEND_BUFFER_SIZE: 3;
-export declare const TCP_OPTION_RECV_BUFFER_SIZE: 4;
-export type TcpSocketOption = {
-    type: typeof TCP_OPTION_NODELAY;
-    value: boolean;
-} | {
-    type: typeof TCP_OPTION_TTL;
-    value: number;
-} | {
-    type: typeof TCP_OPTION_KEEPALIVE;
-    enabled: boolean;
-    initialDelaySeconds: number;
-} | {
-    type: typeof TCP_OPTION_SEND_BUFFER_SIZE;
-    value: number;
-} | {
-    type: typeof TCP_OPTION_RECV_BUFFER_SIZE;
-    value: number;
-};
-export declare const parseClientMetadataTcpSetOptionPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: "ClientMetadataTcpSetOptionPacket";
-    offset: number;
-    id: number;
-    socketId: number;
-    option: TcpSocketOption;
-};
-export type ClientMetadataTcpSetOptionPacket = ReturnType<typeof parseClientMetadataTcpSetOptionPacket>;
-export declare const packClientMetadataTcpSetOptionPacket: (packet: {
-    id: number;
-    socketId: number;
-    option: TcpSocketOption;
-}) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: "ServerMetadataTcpSetOptionAckPacket";
-    offset: number;
-    id: number;
-    socketId: number;
-    errorLength: number;
-    error: string;
-};
-export type ServerMetadataTcpSetOptionAckPacket = ReturnType<typeof parseServerMetadataTcpSetOptionAckPacket>;
-export declare const packServerMetadataTcpSetOptionAckPacket: (packet: Omit<ServerMetadataTcpSetOptionAckPacket, "_type" | "offset" | "errorLength">) => Uint8Array<ArrayBuffer>;

package/api/webvpn/packets/tcp.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/webvpn/packets/udp.d.ts

@@ -1,196 +0,0 @@
-export declare const parseClientMetadataUdpSocketBindPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataUdpSocketBindPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly localPort: number;
-};
-export type ClientMetadataUdpSocketBindPacket = ReturnType<typeof parseClientMetadataUdpSocketBindPacket>;
-export declare const packClientMetadataUdpSocketBindPacket: (packet: Omit<ClientMetadataUdpSocketBindPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseClientMetadataUdpSocketUnbindPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataUdpSocketUnbindPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ClientMetadataUdpSocketUnbindPacket = ReturnType<typeof parseClientMetadataUdpSocketUnbindPacket>;
-export declare const packClientMetadataUdpSocketUnbindPacket: (packet: Omit<ClientMetadataUdpSocketUnbindPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseClientMetadataUdpSocketConnectPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientMetadataUdpSocketConnectPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly remotePort: number;
-};
-export type ClientMetadataUdpSocketConnectPacket = ReturnType<typeof parseClientMetadataUdpSocketConnectPacket>;
-export declare const packClientMetadataUdpSocketConnectPacket: (packet: Omit<ClientMetadataUdpSocketConnectPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseClientUdpDataPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ClientUdpDataPacket";
-    readonly offset: number;
-    readonly socketId: number;
-    readonly remoteAddressType: 0 | 1 | 2;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6 | undefined;
-    readonly remotePort: number | undefined;
-    readonly dataLength: number;
-    readonly data: ArrayBuffer;
-};
-export type ClientUdpDataPacket = ReturnType<typeof parseClientUdpDataPacket>;
-export declare const packClientUdpDataPacket: (packet: Omit<ClientUdpDataPacket, "_type" | "offset" | "dataLength">) => Uint8Array<ArrayBuffer>;
-export declare const parseClientUdpDataPackets: (buffer: ArrayBuffer) => {
-    packets: {
-        readonly _type: "ClientUdpDataPacket";
-        readonly offset: number;
-        readonly socketId: number;
-        readonly remoteAddressType: 0 | 1 | 2;
-        readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6 | undefined;
-        readonly remotePort: number | undefined;
-        readonly dataLength: number;
-        readonly data: ArrayBuffer;
-    }[];
-    remaining: ArrayBuffer;
-};
-export declare const parseServerMetadataUdpSocketBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataUdpSocketBoundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly localPort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-export type ServerMetadataUdpSocketBoundPacket = ReturnType<typeof parseServerMetadataUdpSocketBoundPacket>;
-export declare const packServerMetadataUdpSocketBoundPacket: (packet: Omit<ServerMetadataUdpSocketBoundPacket, "_type" | "offset" | "errorLength">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataUdpSocketUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataUdpSocketUnboundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ServerMetadataUdpSocketUnboundPacket = ReturnType<typeof parseServerMetadataUdpSocketUnboundPacket>;
-export declare const packServerMetadataUdpSocketUnboundPacket: (packet: Omit<ServerMetadataUdpSocketUnboundPacket, "_type" | "offset">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataUdpSocketConnectedPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataUdpSocketConnectedPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6;
-    readonly remotePort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-export type ServerMetadataUdpSocketConnectedPacket = ReturnType<typeof parseServerMetadataUdpSocketConnectedPacket>;
-export declare const packServerMetadataUdpSocketConnectedPacket: (packet: Omit<ServerMetadataUdpSocketConnectedPacket, "_type" | "offset" | "errorLength">) => Uint8Array<ArrayBuffer>;
-export type ServerMetadataUdpSocketPacket = ServerMetadataUdpSocketBoundPacket | ServerMetadataUdpSocketConnectedPacket | ServerMetadataUdpSocketUnboundPacket;
-export declare const parseServerUdpDataPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerUdpDataPacket";
-    readonly offset: number;
-    readonly socketId: number;
-    readonly remoteAddressType: 0 | 1 | 2;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6 | undefined;
-    readonly remotePort: number | undefined;
-    readonly dataLength: number;
-    readonly data: ArrayBuffer;
-};
-export type ServerUdpDataPacket = ReturnType<typeof parseServerUdpDataPacket>;
-export declare const packServerUdpDataPacket: (packet: Omit<ServerUdpDataPacket, "_type" | "offset" | "dataLength">) => Uint8Array<ArrayBuffer>;
-export declare const parseServerUdpDataPackets: (buffer: ArrayBuffer) => {
-    packets: {
-        readonly _type: "ServerUdpDataPacket";
-        readonly offset: number;
-        readonly socketId: number;
-        readonly remoteAddressType: 0 | 1 | 2;
-        readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6 | undefined;
-        readonly remotePort: number | undefined;
-        readonly dataLength: number;
-        readonly data: ArrayBuffer;
-    }[];
-    remaining: ArrayBuffer;
-};
-export declare const createServerDatagramPacketTransformStream: () => TransformStream<Uint8Array<ArrayBufferLike>, {
-    readonly _type: "ServerUdpDataPacket";
-    readonly offset: number;
-    readonly socketId: number;
-    readonly remoteAddressType: 0 | 1 | 2;
-    readonly remoteAddress: import('ip-address').Address4 | import('ip-address').Address6 | undefined;
-    readonly remotePort: number | undefined;
-    readonly dataLength: number;
-    readonly data: ArrayBuffer;
-}>;
-export declare const UDP_OPTION_BROADCAST: 0;
-export declare const UDP_OPTION_TTL: 1;
-export declare const UDP_OPTION_MULTICAST_TTL_V4: 2;
-export declare const UDP_OPTION_MULTICAST_LOOP_V4: 3;
-export declare const UDP_OPTION_MULTICAST_LOOP_V6: 4;
-export declare const UDP_OPTION_ADD_MEMBERSHIP_V4: 5;
-export declare const UDP_OPTION_DROP_MEMBERSHIP_V4: 6;
-export declare const UDP_OPTION_ADD_MEMBERSHIP_V6: 7;
-export declare const UDP_OPTION_DROP_MEMBERSHIP_V6: 8;
-export declare const UDP_OPTION_SEND_BUFFER_SIZE: 9;
-export declare const UDP_OPTION_RECV_BUFFER_SIZE: 10;
-export type UdpSocketOption = {
-    type: typeof UDP_OPTION_BROADCAST;
-    value: boolean;
-} | {
-    type: typeof UDP_OPTION_TTL;
-    value: number;
-} | {
-    type: typeof UDP_OPTION_MULTICAST_TTL_V4;
-    value: number;
-} | {
-    type: typeof UDP_OPTION_MULTICAST_LOOP_V4;
-    value: boolean;
-} | {
-    type: typeof UDP_OPTION_MULTICAST_LOOP_V6;
-    value: boolean;
-} | {
-    type: typeof UDP_OPTION_ADD_MEMBERSHIP_V4;
-    group: Uint8Array;
-    interface: Uint8Array;
-} | {
-    type: typeof UDP_OPTION_DROP_MEMBERSHIP_V4;
-    group: Uint8Array;
-    interface: Uint8Array;
-} | {
-    type: typeof UDP_OPTION_ADD_MEMBERSHIP_V6;
-    group: Uint8Array;
-    ifIndex: number;
-} | {
-    type: typeof UDP_OPTION_DROP_MEMBERSHIP_V6;
-    group: Uint8Array;
-    ifIndex: number;
-} | {
-    type: typeof UDP_OPTION_SEND_BUFFER_SIZE;
-    value: number;
-} | {
-    type: typeof UDP_OPTION_RECV_BUFFER_SIZE;
-    value: number;
-};
-export declare const parseClientMetadataUdpSetOptionPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: "ClientMetadataUdpSetOptionPacket";
-    offset: number;
-    id: number;
-    socketId: number;
-    option: UdpSocketOption;
-};
-export type ClientMetadataUdpSetOptionPacket = ReturnType<typeof parseClientMetadataUdpSetOptionPacket>;
-export declare const packClientMetadataUdpSetOptionPacket: (packet: {
-    id: number;
-    socketId: number;
-    option: UdpSocketOption;
-}) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataUdpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: "ServerMetadataUdpSetOptionAckPacket";
-    offset: number;
-    id: number;
-    socketId: number;
-    errorLength: number;
-    error: string;
-};
-export type ServerMetadataUdpSetOptionAckPacket = ReturnType<typeof parseServerMetadataUdpSetOptionAckPacket>;
-export declare const packServerMetadataUdpSetOptionAckPacket: (packet: Omit<ServerMetadataUdpSetOptionAckPacket, "_type" | "offset" | "errorLength">) => Uint8Array<ArrayBuffer>;

package/api/webvpn/packets/udp.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/webvpn/packets/utils.d.ts

@@ -1,23 +0,0 @@
-import { Address4, Address6 } from 'ip-address';
-export declare const createPacketTransformStream: <T>(func: (buffer: ArrayBuffer) => {
-    packets: T[];
-    remaining: ArrayBuffer;
-}) => TransformStream<Uint8Array<ArrayBufferLike>, T>;
-export declare const parseAddress: <T extends boolean = false>(offset: number, buffer: ArrayBuffer, view: DataView, optionalAddress?: T) => (T extends true ? {
-    offset: number;
-    addressType: 2;
-    address: undefined;
-    port: undefined;
-} : never) | {
-    offset: number;
-    addressType: 0;
-    address: Address4;
-    port: number;
-} | {
-    offset: number;
-    addressType: 1;
-    address: Address6;
-    port: number;
-};
-export type Address = Omit<ReturnType<typeof parseAddress>, 'offset'>;
-export declare const packAddress: ({ addressType, address, port }: Address, offset: number, view: DataView, typedView: Uint8Array, optionalAddress?: boolean) => number;

package/api/webvpn/packets/utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/webvpn/tcp-listener.d.ts

@@ -1,11 +0,0 @@
-import { TcpSocketResult } from './tcp';
-export declare const webVpnTcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
-    localAddress: string;
-    localPort: number;
-    onConnection: (connection: TcpSocketResult) => void;
-}) => Promise<{
-    localAddress: string;
-    localFamily: "IPv4" | "IPv6";
-    localPort: number;
-    close: () => Promise<void>;
-}>;