@fkn/lib 0.4.8 → 0.5.0

package/dgram.d.ts

@@ -0,0 +1,537 @@
+import { Socket as Socket$1, SocketOptions, BindOptions, SocketType, RemoteInfo } from 'dgram';
+import { AddressInfo } from 'net';
+import * as ip_address from 'ip-address';
+import { Address4, Address6 } from 'ip-address';
+import { EventEmitter } from 'events';
+import { Buffer } from 'buffer';
+
+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: ip_address.Address4 | ip_address.Address6;
+    readonly localPort: number;
+    readonly errorLength: number;
+    readonly error: string;
+};
+type ServerMetadataUdpSocketBoundPacket = ReturnType<typeof parseServerMetadataUdpSocketBoundPacket>;
+declare const parseServerMetadataUdpSocketUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+    readonly _type: "ServerMetadataUdpSocketUnboundPacket";
+    readonly offset: number;
+    readonly id: number;
+    readonly socketId: number;
+};
+type ServerMetadataUdpSocketUnboundPacket = ReturnType<typeof parseServerMetadataUdpSocketUnboundPacket>;
+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: ip_address.Address4 | ip_address.Address6;
+    readonly remotePort: number;
+    readonly errorLength: number;
+    readonly error: string;
+};
+type ServerMetadataUdpSocketConnectedPacket = ReturnType<typeof parseServerMetadataUdpSocketConnectedPacket>;
+declare const UDP_OPTION_BROADCAST: 0;
+declare const UDP_OPTION_TTL: 1;
+declare const UDP_OPTION_MULTICAST_TTL_V4: 2;
+declare const UDP_OPTION_MULTICAST_LOOP_V4: 3;
+declare const UDP_OPTION_MULTICAST_LOOP_V6: 4;
+declare const UDP_OPTION_ADD_MEMBERSHIP_V4: 5;
+declare const UDP_OPTION_DROP_MEMBERSHIP_V4: 6;
+declare const UDP_OPTION_ADD_MEMBERSHIP_V6: 7;
+declare const UDP_OPTION_DROP_MEMBERSHIP_V6: 8;
+declare const UDP_OPTION_SEND_BUFFER_SIZE: 9;
+declare const UDP_OPTION_RECV_BUFFER_SIZE: 10;
+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;
+};
+declare const parseServerMetadataUdpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+    _type: "ServerMetadataUdpSetOptionAckPacket";
+    offset: number;
+    id: number;
+    socketId: number;
+    errorLength: number;
+    error: string;
+};
+type ServerMetadataUdpSetOptionAckPacket = ReturnType<typeof parseServerMetadataUdpSetOptionAckPacket>;
+
+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: ip_address.Address4 | ip_address.Address6;
+    readonly localPort: number;
+    readonly remoteAddressType: 0 | 1;
+    readonly remoteAddress: ip_address.Address4 | ip_address.Address6;
+    readonly remotePort: number;
+    readonly errorLength: number;
+    readonly error: string;
+};
+type ServerMetadataTcpSocketConnectedPacket = ReturnType<typeof parseServerMetadataTcpSocketConnectedPacket>;
+declare const parseServerMetadataTcpSocketShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+    readonly _type: "ServerMetadataTcpSocketShutdownPacket";
+    readonly offset: number;
+    readonly id: number;
+    readonly socketId: number;
+};
+type ServerMetadataTcpSocketShutdownPacket = ReturnType<typeof parseServerMetadataTcpSocketShutdownPacket>;
+declare const TCP_OPTION_NODELAY: 0;
+declare const TCP_OPTION_TTL: 1;
+declare const TCP_OPTION_KEEPALIVE: 2;
+declare const TCP_OPTION_SEND_BUFFER_SIZE: 3;
+declare const TCP_OPTION_RECV_BUFFER_SIZE: 4;
+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;
+};
+declare const parseServerMetadataTcpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+    _type: "ServerMetadataTcpSetOptionAckPacket";
+    offset: number;
+    id: number;
+    socketId: number;
+    errorLength: number;
+    error: string;
+};
+type ServerMetadataTcpSetOptionAckPacket = ReturnType<typeof parseServerMetadataTcpSetOptionAckPacket>;
+
+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: ip_address.Address4 | ip_address.Address6;
+    readonly localPort: number;
+    readonly errorLength: number;
+    readonly error: string;
+};
+type ServerMetadataTcpSocketListenerBoundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerBoundPacket>;
+declare const parseServerMetadataTcpSocketListenerUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+    readonly _type: "ServerMetadataTcpSocketListenerUnboundPacket";
+    readonly offset: number;
+    readonly id: number;
+    readonly socketId: number;
+};
+type ServerMetadataTcpSocketListenerUnboundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerUnboundPacket>;
+
+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;
+};
+type ServerMetadataHeaderPacket = ReturnType<typeof parseServerMetadataHeaderPacket>;
+type ServerMetadataPacket = ServerMetadataHeaderPacket | ServerMetadataTcpSocketConnectedPacket | ServerMetadataTcpSocketShutdownPacket | ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket | ServerMetadataUdpSocketBoundPacket | ServerMetadataUdpSocketUnboundPacket | ServerMetadataUdpSocketConnectedPacket | ServerMetadataTcpSetOptionAckPacket | ServerMetadataUdpSetOptionAckPacket;
+
+type BidirectionalStreams = {
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+};
+declare const makeWebVPNWebTransport: () => Promise<{
+    webtransport: WebTransport;
+    isClosed: () => boolean;
+    getNewPacketId: () => number;
+    getTcpDataReadableStreamForSocketId: (socketId: number, options?: {
+        signal?: AbortSignal;
+    }) => Promise<BidirectionalStreams>;
+    getUdpDataReadableStreamForSocketId: (socketId: number) => ReadableStream<{
+        readonly _type: "ServerUdpDataPacket";
+        readonly offset: number;
+        readonly socketId: number;
+        readonly remoteAddressType: 0 | 1 | 2;
+        readonly remoteAddress: Address4 | Address6 | undefined;
+        readonly remotePort: number | undefined;
+        readonly dataLength: number;
+        readonly data: ArrayBuffer;
+    }>;
+    claimUdpRawStream: (socketId: number, sink: (packetBytes: Uint8Array) => void) => void;
+    releaseUdpRawStream: (socketId: number) => void;
+    getPacketForId: (packetId: number) => Promise<ServerMetadataPacket>;
+    getMetadataReadableStreamForSocketId: (socketId: number) => ReadableStream<ServerMetadataPacket>;
+    getMetadataReadableStreamForLocalAddress: (address: Address4 | Address6) => ReadableStream<ServerMetadataPacket>;
+    getMetadataReadableStreamForLocalPort: (port: number) => ReadableStream<ServerMetadataPacket>;
+    getMetadataWritableStream: () => WritableStream<Uint8Array<ArrayBufferLike>>;
+    getDatagramWritableStream: () => WritableStream<Uint8Array<ArrayBufferLike>>;
+    presentRateToken: () => Promise<void>;
+}>;
+type WebVPNWebTransport = Awaited<ReturnType<typeof makeWebVPNWebTransport>>;
+
+declare const processTcpSocket: ({ connectedPacket, dataReadableStream, dataWritableStream, metadataReadableStream, metadataWriter, dataStreamAbort, webVpnWebTransport }: {
+    connectedPacket: ServerMetadataTcpSocketConnectedPacket;
+    dataReadableStream: ReadableStream<Uint8Array>;
+    dataWritableStream: WritableStream<Uint8Array>;
+    metadataReadableStream: ReadableStream<ServerMetadataPacket>;
+    metadataWriter: WritableStreamDefaultWriter<Uint8Array>;
+    dataStreamAbort?: AbortController;
+    webVpnWebTransport: WebVPNWebTransport;
+}) => 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: TcpSocketOption) => Promise<void>;
+}>;
+type TcpSocketResult = Awaited<ReturnType<typeof processTcpSocket>>;
+
+type StorageEntry = {
+    path: string;
+    size: number;
+    contentType: string | null;
+    updatedAt: string;
+};
+type StorageQuota = {
+    usedBytes: number;
+    limitBytes: number;
+    remaining: number;
+    objects: number;
+    maxObjects: number;
+};
+type WriteData = Blob | ArrayBuffer | Uint8Array | string;
+
+type Account = {
+    name: string;
+    image: string | null;
+    premium: boolean;
+    premiumUntil: string | null;
+};
+
+type AddressLookupResult = {
+    address: string;
+    family: 0 | 4 | 6;
+};
+
+type Quota = {
+    overQuota: boolean;
+    remaining: number;
+    usedBytes: number;
+    limitBytes: number;
+    premium: boolean;
+    bytesPerSecond: number;
+};
+
+declare const resolvers: {
+    readonly cloud: {
+        readonly fetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
+            render?: boolean;
+        }) => Promise<Response>;
+        readonly quota: () => Promise<Quota>;
+        readonly dns: {
+            readonly lookup: <T extends boolean = false>(hostname: string, options?: {
+                all?: T;
+                family: 0 | 4 | 6;
+            }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
+        };
+        readonly fs: {
+            readonly available: () => Promise<boolean>;
+            readonly list: () => Promise<StorageEntry[]>;
+            readonly quota: () => Promise<StorageQuota>;
+            readonly readFile: (path: string) => Promise<Blob>;
+            readonly writeFile: (path: string, data: WriteData, contentType: string | null) => Promise<void>;
+            readonly remove: (path: string) => Promise<void>;
+        };
+        readonly webvpn: {
+            readonly tcpSocket: ({ 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: TcpSocketOption) => Promise<void>;
+            }>;
+            readonly tcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
+                localAddress: string;
+                localPort: number;
+                onConnection: (connection: TcpSocketResult) => void;
+            }) => Promise<{
+                localAddress: string;
+                localFamily: "IPv4" | "IPv6";
+                localPort: number;
+                close: () => Promise<void>;
+            }>;
+            readonly udpSocket: ({ type, port, address, dataPort }: {
+                type: "udp4" | "udp6";
+                port: number;
+                address: string;
+                dataPort?: boolean;
+            }) => Promise<{
+                socketId: number;
+                dataPort: MessagePort | undefined;
+                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: UdpSocketOption) => Promise<void>;
+            }>;
+        };
+    };
+    readonly overlay: {
+        readonly setHost: (push: (state: {
+            modal: boolean;
+            rects: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            }[];
+        }) => unknown) => void;
+    };
+    readonly installPrompt: {
+        readonly show: (reason?: string) => Promise<void>;
+        readonly hide: () => void;
+    };
+    readonly connect: {
+        readonly prompt: (consumerOrigin: string) => Promise<boolean>;
+    };
+    readonly account: {
+        readonly info: () => Promise<Account | null>;
+        readonly login: (consumerOrigin: string) => Promise<boolean>;
+        readonly logout: () => void;
+        readonly onChange: (listener: () => void) => (() => void);
+    };
+    readonly proxyFetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
+        render?: boolean;
+    }) => Promise<Response>;
+    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: TcpSocketOption) => Promise<void>;
+    }>;
+    readonly webVpnTcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
+        localAddress: string;
+        localPort: number;
+        onConnection: (connection: TcpSocketResult) => void;
+    }) => Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        close: () => Promise<void>;
+    }>;
+    readonly webVpnUdpSocket: ({ type, port, address, dataPort }: {
+        type: "udp4" | "udp6";
+        port: number;
+        address: string;
+        dataPort?: boolean;
+    }) => Promise<{
+        socketId: number;
+        dataPort: MessagePort | undefined;
+        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: UdpSocketOption) => Promise<void>;
+    }>;
+    readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
+        all?: T;
+        family: 0 | 4 | 6;
+    }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
+    readonly setOverlayHost: (push: (state: {
+        modal: boolean;
+        rects: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }[];
+    }) => unknown) => void;
+    readonly showInstallPrompt: (reason?: string) => Promise<void>;
+    readonly hideInstallPrompt: () => void;
+};
+type Resolvers = typeof resolvers;
+
+type WebVpnUdpSocket = Resolvers['cloud']['webvpn']['udpSocket'];
+interface EventEmitterOptions {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+declare class Socket extends EventEmitter implements Socket$1 {
+    _type: 'udp4' | 'udp6';
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _remoteAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<WebVpnUdpSocket>> | undefined>;
+    _dataPort?: MessagePort;
+    _socketId?: number;
+    _sendQueue: Uint8Array[];
+    _sendQueueBytes: number;
+    _sendFlushScheduled: boolean;
+    _peerTailCache: Map<string, Uint8Array<ArrayBufferLike>>;
+    constructor(options: SocketOptions & EventEmitterOptions & {
+        connection?: ReturnType<WebVpnUdpSocket>;
+    });
+    _lastRecvBufferSize: number;
+    _lastSendBufferSize: number;
+    _lastTtl: number;
+    _lastMulticastTtl: number;
+    _lastMulticastLoopback: boolean;
+    _setUdpOption(option: UdpSocketOption): void;
+    _onDataPortBatch(buffer: ArrayBuffer): void;
+    _peerTail(address: string | undefined, port: number | undefined): Uint8Array;
+    _portSend(message: Uint8Array, address: string | undefined, port: number | undefined): void;
+    addMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    address(): AddressInfo;
+    bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this;
+    bind(port?: number | undefined, callback?: (() => void) | undefined): this;
+    bind(callback?: (() => void) | undefined): this;
+    bind(options: BindOptions, callback?: (() => void) | undefined): this;
+    close(callback?: (() => void) | undefined): this;
+    connect(port: number, address?: string, callback?: () => void): void;
+    connect(port: number, callback: () => void): void;
+    disconnect(): void;
+    dropMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+    getSendQueueSize(): number;
+    getSendQueueCount(): number;
+    ref(): this;
+    remoteAddress(): AddressInfo;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: unknown, offset?: unknown, length?: unknown, port?: unknown, address?: unknown, callback?: unknown): void;
+    setBroadcast(flag: boolean): void;
+    setMulticastInterface(multicastInterface: string): void;
+    setMulticastLoopback(flag: boolean): boolean;
+    setMulticastTTL(ttl: number): number;
+    setRecvBufferSize(size: number): void;
+    setSendBufferSize(size: number): void;
+    setTTL(ttl: number): number;
+    unref(): this;
+    addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => Socket;
+
+export { Socket, createSocket };

package/dgram.js

@@ -0,0 +1,4 @@
+import "./api-ByfayMm1.js";
+import "./utils-CNydj3OT.js";
+import { n as e, t } from "./dgram-5YUb70O2.js";
+export { t as Socket, e as createSocket };

package/dns.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./chunk-B6C_zzib.cjs`),t=require(`./api-CDb2pv7C.cjs`);var n=e.n({lookup:()=>r}),r=(e,n)=>t.t.then(t=>t.cloud.dns.lookup(e,n));exports.lookup=r,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return n}});

package/dns.d.ts

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

package/dns.js

@@ -0,0 +1,6 @@
+import { n as e } from "./chunk-CPXzm0be.js";
+import { t } from "./api-ByfayMm1.js";
+//#region src/lib/dns.ts
+var n = /* @__PURE__ */ e({ lookup: () => r }), r = (e, n) => t.then((t) => t.cloud.dns.lookup(e, n));
+//#endregion
+export { r as lookup, n as t };

package/extension-9Uv_0HdS.cjs

@@ -0,0 +1 @@
+const e=require(`./chunk-B6C_zzib.cjs`),t=require(`./locator-Cf7M3QKN.cjs`),n=require(`./api-CDb2pv7C.cjs`),r=require(`./proxy-A9UvWUaF.cjs`),i=require(`./desktop.cjs`);let a=require(`osra`);var o=`FKN_WEB_EXTENSION_MAIN_WORLD_CONTENT_SCRIPT_ENABLED_EVENT_KEY`,s=`fknExtension`,c=(0,a.createTypedEventTarget)();typeof document<`u`&&document.addEventListener(o,()=>{c.dispatchEvent(new CustomEvent(`statuschange`,{detail:{enabled:l()}}))});var l=()=>typeof document>`u`?!1:document.documentElement.dataset[s]===`true`,u=null,d=e=>{u=e},f=150,p=(e=1e3)=>new Promise((t,n)=>{if(l())return t();let r,i=e=>{clearTimeout(r),s.disconnect(),document.removeEventListener(`readystatechange`,c),e()},a=()=>i(async()=>{if(u&&(await u().catch(()=>{}),l()))return t();n(Error(`The FKN WebExtension is not installed, enabled or not exposed on this page.`))}),o=()=>{clearTimeout(r),r=setTimeout(()=>l()?i(t):a(),f)},s=new MutationObserver(()=>{l()&&i(t)}),c=()=>{document.readyState===`complete`&&!l()&&o()};if(r=setTimeout(a,e),s.observe(document.documentElement,{attributes:!0,attributeFilter:[`data-fkn-extension`]}),document.addEventListener(`readystatechange`,c),document.readyState===`complete`)return o();l()&&i(t)}),m,h=new Proxy({},{get:(e,n)=>async(...e)=>{await p(),m??=(0,a.expose)({},{transport:window,revivableModules:t.l});let r=(await m)[n];return r(...e)}}),g={scope:`network.fetch`,category:`network`,severity:0,title:`Fetch data from other sites`,description:`Lets the app download public data from other websites directly, past the usual cross-origin limits.`},_={scope:`network.fetchCredentialed`,category:`network`,severity:3,unsafe:!0,title:`Fetch from other sites, signed in as you`,description:`Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.`},v={scope:`network.fetchLocal`,category:`network`,severity:3,unsafe:!0,title:`Access devices on your local network`,description:`Lets the app reach devices and services on your home or work network, which websites normally cannot touch.`},y=e=>{let t=e.match(/^(\d+)\.(\d+)\.\d+\.\d+$/);if(!t)return!1;let[n,r]=[Number(t[1]),Number(t[2])];return n===10||n===127||n===0||n===169&&r===254||n===172&&r>=16&&r<=31||n===192&&r===168},b=e=>{let t;try{t=new URL(e)}catch{return!1}let n=t.hostname.replace(/^\[|\]$/g,``).toLowerCase().replace(/\.$/,``);return n===`localhost`||n.endsWith(`.localhost`)||n.endsWith(`.local`)||n.endsWith(`.internal`)||n.endsWith(`.home.arpa`)?!0:n.includes(`:`)?n===`::`||n===`::1`||n.startsWith(`fc`)||n.startsWith(`fd`)||/^fe[89ab]/.test(n)||n.startsWith(`::ffff:`):y(n)},x=[`fkn.app`,`fkn.dev`],S=e=>{let t;try{t=new URL(e)}catch{return!1}if(t.protocol===`chrome-extension:`||t.protocol===`moz-extension:`)return!0;let n=t.hostname;return x.some(e=>n===e||n.endsWith(`.${e}`))},C=e=>{if(S(e))throw Error(`fetch: refusing to target the extension's own pages or FKN platform domains`)},w=[`origin`,`referer`],T=e=>{if(!e?.headers)return;let t=new Headers(e.headers),n=w.map(e=>{let n=t.get(e);return n===null?void 0:[e,n]}).filter(e=>e!==void 0);return n.length?n:void 0},E=async(e,t)=>{let n=new Request(e,t);C(n.url);let r=n.body?await n.arrayBuffer():null;return h.proxyFetch({url:n.url,method:n.method,headers:[...n.headers],body:r,credentials:t?.credentials===`include`?`include`:`omit`,redirect:n.redirect,unsafeHeaders:T(t),reason:t?.reason,signal:t?.signal??void 0})},D={scope:`network.readCookie`,category:`network`,severity:3,unsafe:!0,title:`Read a site’s cookie`,description:`Lets the app read a named cookie from another site, which can include the login token only that site should see.`},O={get:e=>h.getCookie(e)},k={scope:`network.modifyRequestHeaders`,category:`network`,severity:2,unsafe:!0,title:`Rewrite request headers to other sites`,description:`Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.`},A=e=>h.setRequestHeaderRule(e),j=e=>h.removeRequestHeaderRule({ruleId:e});(()=>{let e={},n=[...t.t.selectorModules,...t.i.selectorModules];for(let t of n)t.render&&!(t.type in e)&&(e[t.type]=t.render);return e})();var M=`FKN_WEB_EXTENSION_ATTACH_FRAME_EVENT_KEY`,N=e=>{if(!e||e===`about:blank`)return!1;let t;try{t=new URL(e,location.href)}catch{return!1}if(t.protocol===`chrome-extension:`||t.protocol===`moz-extension:`)return!0;if(t.protocol===`about:`)return!1;let n=t.hostname;return n===`fkn.app`||n.endsWith(`.fkn.app`)},P=e=>{if(N(e))throw Error(`attachFrame: refusing to target the extension's own pages or fkn.app`)},F={scope:`embed.iframe`,category:`embed`,severity:0,title:`Load another website inside this app`,description:`Lets the app embed external pages directly inside its own view.`},I={scope:`embed.open`,category:`embed`,severity:0,title:`Open a website inside this app`,description:`Lets the app navigate to another site without leaving its window.`},L={scope:`embed.evaluate`,category:`embed`,severity:0,title:`Run app code inside an embedded frame`,description:`Lets the app execute its own code inside a page it embedded, to read back a computed result.`},R=async({iframe:e,domains:n=[],syncCookies:r=!0,lockdown:i=!1})=>{let a=crypto.randomUUID();if(P(e.src),await p(),!e.isConnected)throw Error(`attachFrame: the iframe must be connected to the document before attaching`);e.dispatchEvent(new CustomEvent(M,{detail:a}));let{executeLocator:o,ensureLocatorPermission:s,goto:c,evaluate:l}=await h.attachFrame({marker:a,domains:n,syncCookies:r,lockdown:i}),u=t.r(o,s),d=(e,t={})=>(P(e),c({url:e,...t})),f=((e,t)=>l(e,t)),m=()=>e.src;return{...u,goto:d,evaluate:f,url:m}},z={request:e=>h.requestPermissions(e.map(e=>({key:e.key,scope:e.scope??``,reason:e.reason})))},B=async e=>{if(typeof window>`u`)return!1;if(l())return!0;let t=await n.t,r=null,i=new Promise(e=>{r=()=>{l()&&e(!0)},c.addEventListener(`statuschange`,r)}),a=t.installPrompt.show(e).then(()=>!1),o=await Promise.race([i,a]);return r&&c.removeEventListener(`statuschange`,r),await t.installPrompt.hide().catch(()=>{}),o},V=null;d(()=>(V||=B().then(()=>void 0).finally(()=>{V=null}),V));var H=()=>typeof document<`u`&&l(),U=async(e,t)=>{if(r.n(e),t?.credentials===`include`){if(typeof document>`u`)throw Error(`fetch with credentials needs the FKN extension, which only exists in window realms`);return E(e,t)}return H()?E(e,{...t,credentials:`omit`}):i.available()?i.fetch(e,t):r.t(e,t)},W=e.n({ATTACH_FRAME_EVENT_KEY:()=>M,assertAttachableFrameUrl:()=>P,assertFetchableUrl:()=>C,attachFrame:()=>R,attachFramePermission:()=>F,available:()=>H,box:()=>t.u,cookies:()=>O,createVideoElementHandle:()=>t.d,evaluatePermission:()=>L,events:()=>c,extension:()=>c,fetch:()=>E,fetchCredentialedPermission:()=>_,fetchLocalPermission:()=>v,fetchPermission:()=>g,gotoPermission:()=>I,handleRevivableModules:()=>t.l,isBlockedFetchUrl:()=>S,isBlockedFrameUrl:()=>N,isExtensionExposed:()=>l,isLocalNetworkUrl:()=>b,isType:()=>t.f,modifyRequestHeadersPermission:()=>k,permissions:()=>z,promptInstall:()=>B,readCookiePermission:()=>D,removeRequestHeaderRule:()=>j,revive:()=>t.p,setMissingExtensionHandler:()=>d,setRequestHeaderRule:()=>A,type:()=>t.m,waitForExtensionExposure:()=>p});Object.defineProperty(exports,`C`,{enumerable:!0,get:function(){return S}}),Object.defineProperty(exports,`D`,{enumerable:!0,get:function(){return d}}),Object.defineProperty(exports,`E`,{enumerable:!0,get:function(){return l}}),Object.defineProperty(exports,`O`,{enumerable:!0,get:function(){return p}}),Object.defineProperty(exports,`S`,{enumerable:!0,get:function(){return g}}),Object.defineProperty(exports,`T`,{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,`_`,{enumerable:!0,get:function(){return D}}),Object.defineProperty(exports,`a`,{enumerable:!0,get:function(){return z}}),Object.defineProperty(exports,`b`,{enumerable:!0,get:function(){return _}}),Object.defineProperty(exports,`c`,{enumerable:!0,get:function(){return R}}),Object.defineProperty(exports,`d`,{enumerable:!0,get:function(){return I}}),Object.defineProperty(exports,`f`,{enumerable:!0,get:function(){return N}}),Object.defineProperty(exports,`g`,{enumerable:!0,get:function(){return O}}),Object.defineProperty(exports,`h`,{enumerable:!0,get:function(){return A}}),Object.defineProperty(exports,`i`,{enumerable:!0,get:function(){return B}}),Object.defineProperty(exports,`l`,{enumerable:!0,get:function(){return F}}),Object.defineProperty(exports,`m`,{enumerable:!0,get:function(){return j}}),Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return U}}),Object.defineProperty(exports,`o`,{enumerable:!0,get:function(){return M}}),Object.defineProperty(exports,`p`,{enumerable:!0,get:function(){return k}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return H}}),Object.defineProperty(exports,`s`,{enumerable:!0,get:function(){return P}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return W}}),Object.defineProperty(exports,`u`,{enumerable:!0,get:function(){return L}}),Object.defineProperty(exports,`v`,{enumerable:!0,get:function(){return C}}),Object.defineProperty(exports,`w`,{enumerable:!0,get:function(){return b}}),Object.defineProperty(exports,`x`,{enumerable:!0,get:function(){return v}}),Object.defineProperty(exports,`y`,{enumerable:!0,get:function(){return E}});