socket-function 0.154.0 → 0.156.0

package/mobx/UrlParam.d.ts

@@ -0,0 +1,13 @@
+export declare class UrlParam<T> {
+    private key;
+    private defaultValue;
+    constructor(key: string, defaultValue: T);
+    valueSeqNum: {
+        value: number;
+    };
+    get(): T;
+    set(value: T): void;
+    reset(): void;
+    get value(): T;
+    set value(value: T);
+}

package/mobx/observer.d.ts

@@ -0,0 +1,18 @@
+import type preact from "preact";
+import { Reaction } from "mobx";
+export declare function observer<T extends {
+    new (...args: any[]): {
+        render(): preact.ComponentChild;
+        forceUpdate(callback?: () => void): void;
+        componentWillUnmount?(): void;
+    };
+}>(Constructor: T): {
+    new (...args: any[]): {
+        constructOrder: number;
+        reaction: Reaction;
+        componentWillUnmount(): void;
+        render(): preact.ComponentChild;
+        forceUpdate(callback?: () => void): void;
+    };
+    readonly name: string;
+} & T;

package/mobx/promiseToObservable.d.ts

@@ -0,0 +1,8 @@
+export interface InternalResult {
+    result: {
+        value: unknown;
+    } | undefined;
+}
+export declare function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): {
+    value: T | undefined;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.154.0",
+	"version": "0.156.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
@@ -17,6 +17,9 @@
 	"scripts": {
 		"test": "yarn typenode ./test/server.ts",
 		"type": "yarn tsc --noEmit",
+		"emit-dts": "yarn tsc --project tsconfig.declarations.json || exit 0",
+		"generate-index-dts": "node ./generateIndexDts.js",
+		"update-typings": "yarn generate-index-dts && yarn emit-dts",
 		"testsni": "yarn typenode ./src/sniTest.ts"
 	},
 	"devDependencies": {

package/require/CSSShim.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="RequireController.d.ts" />
+export {};

package/require/compileFlags.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="RequireController.d.ts" />
+/// <reference types="node" />
+/**
+ *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
+ *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.
+ *          - Passing true as the fourth argument sets it recursively
+ */
+export declare const forceModule = true;
+declare global {
+}
+export declare function setFlag(require: NodeRequire, request: string, flag: string, recursive?: boolean): void;

package/require/extMapper.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function getExtContentType(ext: string): string;
+export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;

package/require/require.d.ts

@@ -0,0 +1,14 @@
+/// <reference path="../index.d.ts" />
+declare global {
+    var onProgressHandler: undefined | ((progress: {
+        type: string;
+        addValue: number;
+        addMax: number;
+    }) => void);
+    var onErrorHandler: undefined | ((error: string) => void);
+    var BOOT_TIME: number;
+    var builtInModuleExports: {
+        [key: string]: unknown;
+    };
+}
+export declare function requireMain(): void;

package/src/CallFactory.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { CallType } from "../SocketFunctionTypes";
+import * as ws from "ws";
+import * as tls from "tls";
+export interface CallFactory {
+    nodeId: string;
+    lastClosed: number;
+    closedForever?: boolean;
+    isConnected?: boolean;
+    performCall(call: CallType): Promise<unknown>;
+    onNextDisconnect(callback: () => void): void;
+    connectionId: {
+        nodeId: string;
+    };
+}
+export interface SenderInterface {
+    nodeId?: string;
+    _socket?: tls.TLSSocket;
+    send(data: string | Buffer): void;
+    addEventListener(event: "open", listener: () => void): void;
+    addEventListener(event: "close", listener: () => void): void;
+    addEventListener(event: "error", listener: (err: {
+        message: string;
+    }) => void): void;
+    addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
+    readyState: number;
+    ping?(): void;
+}
+export declare function harvestFailedCallCount(): number;
+export declare function getPendingCallCount(): number;
+export declare function harvestCallTimes(): {
+    start: number;
+    end: number;
+}[];
+export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;

package/src/JSONLACKS/JSONLACKS.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export interface JSONLACKS_ParseConfig {
+    extended?: boolean;
+    discardMissingReferences?: boolean;
+}
+export interface JSONLACKS_StringifyConfig {
+    allowObjectMutation?: boolean;
+}
+interface HydrateState {
+    references: Map<string, unknown>;
+    visited: Set<unknown>;
+}
+export declare class JSONLACKS {
+    static readonly LACKS_KEY = "__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__";
+    /** If set to true parses non-quoted field names, comments, trailing commas, etc */
+    static EXTENDED_PARSER: boolean;
+    static IGNORE_MISSING_REFERENCES: boolean;
+    static stringify(obj: unknown, config?: JSONLACKS_StringifyConfig): string;
+    /** Is useful when serializing an array to a file with one object per line */
+    static stringifyFile(obj: unknown[], config?: JSONLACKS_StringifyConfig): Promise<Buffer>;
+    static stringifyFileSync(obj: unknown[], config?: JSONLACKS_StringifyConfig): Buffer;
+    static parse<T>(text: string, config?: JSONLACKS_ParseConfig, hydrateState?: HydrateState): T;
+    static parseLines<T>(buffer: Buffer, config?: JSONLACKS_ParseConfig): Promise<T[]>;
+    private static escapeSpecialObjects;
+    private static hydrateSpecialObjects;
+}
+export {};

package/src/args.d.ts

@@ -0,0 +1,9 @@
+export declare const getArgs: {
+    (): {
+        [key: string]: string | undefined;
+    };
+    reset(): void;
+    set(newValue: {
+        [key: string]: string | undefined;
+    }): void;
+};

package/src/batching.d.ts

@@ -0,0 +1,31 @@
+import { AnyFunction } from "./types";
+export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
+export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
+export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
+export declare function batchFunction<Arg, Result = void>(config: {
+    delay: DelayType;
+    /** Instead of immediately waiting delay, starts by waiting 0ms, and every call increments the delay factor
+     *      by 1. Delay is `factor * (delay / throttleWindow)`. For every delay interval we have no calls, we decrease by
+     *      no_calls/delay.
+     *      - This essentially turns delay into a `calls per second` type indicator (ex, 10ms is 100 callers
+     *          per second, 500ms is 2 calls, etc), which is accurate over delay * throttleWindow time.
+     */
+    throttleWindow?: number;
+    name?: string;
+    noMeasure?: boolean;
+}, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
+export declare function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T): T;
+export declare function runInParallel<T extends (...args: any[]) => Promise<any>>(config: {
+    parallelCount: number;
+    callTimeout?: number;
+}, fnc: T): T;
+export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
+export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+/** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
+export declare function shutdownPolling(): Promise<void>;
+export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
+    maxRetries?: number;
+    shouldRetry?: (message: string) => boolean;
+    minDelay?: number;
+    maxDelay?: number;
+}): T;

package/src/caching.d.ts

@@ -0,0 +1,59 @@
+import { AnyFunction, Args } from "./types";
+export declare function lazy<T>(factory: () => T): {
+    (): T;
+    reset(): void;
+    set(newValue: T): void;
+};
+export declare function cacheEmptyArray<T>(array: T[]): T[];
+export declare function cache<Output, Key, Untracked extends unknown[]>(getValue: (key: Key, ...untracked: Untracked) => Output): {
+    (key: Key, ...untracked: Untracked): Output;
+    clear(key: Key): void;
+    clearAll(): void;
+    forceSet(key: Key, value: Output): void;
+    getAllKeys(): Key[];
+    get(key: Key): Output | undefined;
+};
+/** Makes a cache that limits the number of entries, allowing you to put arbitrary data in it
+ *      without worrying about leaking memory
+  */
+export declare function cacheLimited<Output, Key>(maxCount: number, getValue: (key: Key) => Output): {
+    (input: Key): Output;
+    forceSet(key: Key, value: Output): void;
+    clearKey(key: Key): void;
+    clear(): void;
+};
+export declare function cacheWeak<Output, Key extends object>(getValue: (key: Key) => Output): (key: Key) => Output;
+export declare function cacheList<Value>(getLength: () => number, getValue: (index: number) => Value): {
+    (index: number): Value;
+};
+/** A cache half way between caching based on === and caching based on hash. Caches
+ *      based on arrayEqual, which does === on all values in an array. Requires localized
+ *      caching (as the comparisons don't scale with many candidates, unlike hashing),
+ *      however works with non trival transformations (ex, resolving many persisted overrides
+ *      to get a value), unlike cache().
+ *  Also, limits itself, more of a performance optimization than memory optimization, as it scales
+ *      very poorly with the number of candidates.
+ *
+ *  TIMING: About 6us with limit = 100, array size = 294, and the cache being full.
+ */
+export declare function cacheArrayEqual<Input extends unknown[] | undefined, Output>(map: (arrays: Input) => Output, limit?: number): {
+    (array: Input): Output;
+    clear(array: Input): void;
+    clearAll(): void;
+};
+/** Caches when arguments are ===. See cacheArrayEqual */
+export declare function cacheArgsEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+    clear(...args: Args<Fnc>): void;
+};
+export declare function cacheJSONArgsEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+    clear(...args: unknown[]): void;
+    clearAll(): void;
+};
+export declare function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(fnc: Fnc, limit?: number): Fnc & {
+    clear(configObj: Args<Fnc>[0]): void;
+    clearAll(): void;
+};
+export declare function externalCache<Key, Value>(): {
+    get: (key: Key) => Value | undefined;
+    set: (key: Key, value: Value) => void;
+};

package/src/callHTTPHandler.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import http from "http";
+import { CallType } from "../SocketFunctionTypes";
+export declare function setDefaultHTTPCall(call: CallType): void;
+export declare function getServerLocationFromRequest(request: http.IncomingMessage): {
+    address: string;
+    port: number;
+};
+export declare function getNodeIdsFromRequest(request: http.IncomingMessage): {
+    nodeId: string;
+    localNodeId: string;
+};
+export declare function getCurrentHTTPRequest(): http.IncomingMessage | undefined;
+export declare function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse): Promise<void>;
+declare const resultHeaders: unique symbol;
+type HTTPResultType = Buffer & {
+    [resultHeaders]?: {
+        [header: string]: string;
+    };
+};
+export declare function setHTTPResultHeaders(result: HTTPResultType, headers: {
+    [header: string]: string;
+}): HTTPResultType;
+export {};

package/src/callManager.d.ts

@@ -0,0 +1,21 @@
+/// <reference path="../hot/HotReloadController.d.ts" />
+import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
+export declare function shouldCompressCall(call: CallType): boolean;
+export declare function performLocalCall(config: {
+    call: FullCallType;
+    caller: CallerContext;
+}): Promise<unknown>;
+export declare function isDataImmutable(call: CallType): boolean;
+export declare function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape, config?: {
+    noFunctionMeasure?: boolean;
+}): void;
+export declare function exposeClass(exposedClass: SocketRegistered): void;
+export declare function registerGlobalHook(hook: SocketFunctionHook): void;
+export declare function unregisterGlobalHook(hook: SocketFunctionHook): void;
+export declare function registerGlobalClientHook(hook: SocketFunctionClientHook): void;
+export declare function unregisterGlobalClientHook(hook: SocketFunctionClientHook): void;
+export declare const runClientHooks: (callType: FullCallType, hooks: Exclude<SocketExposedShape[""], undefined>, connectionId: {
+    nodeId: string;
+}) => Promise<ClientHookContext>;
+export declare const runServerHooks: (callType: FullCallType, caller: CallerContext, hooks: Exclude<SocketExposedShape[""], undefined>) => Promise<HookContext>;

package/src/certStore.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/** Must be populated before the server starts */
+export declare function trustCertificate(cert: string | Buffer): void;
+export declare function getTrustedCertificates(): string[];
+export declare function watchTrustedCertificates(callback: (certs: string[]) => void): () => boolean;

package/src/fixLargeNetworkCalls.d.ts

@@ -0,0 +1,2 @@
+export declare function markArrayAsSplitable<T>(data: T[]): T[];
+export declare function isSplitableArray<T>(data: T): data is T & (unknown[]);

package/src/formatting/colors.d.ts

@@ -0,0 +1,42 @@
+export type HSL = {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslText(color: HSL): string;
+export declare function hslToRGB(color: HSL): {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare function hslToHex(color: HSL): string;
+export declare function hslLightenGamma(hsl: HSL, fraction: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslLightenLinear(hsl: HSL, lightness: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslDarkenGamma(hsl: HSL, fraction: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslDarkenLinear(hsl: HSL, lightness: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslAddSaturate(hsl: HSL, saturation: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function hslSetSaturate(hsl: HSL, saturation: number): {
+    h: number;
+    s: number;
+    l: number;
+};

package/src/formatting/format.d.ts

@@ -0,0 +1,24 @@
+export declare function formatTime(milliseconds: number | undefined, maxAbsoluteValue?: number): string;
+export declare function getTargetDecimals(maxAbsoluteValue: number, targetDigits: number): number;
+/** Adds decimal digits to reach digits. If the number is simply too large, it won't remove
+ *      digits, there will instead just be no decimal point.
+ */
+export declare function formatMaxDecimals(num: number, targetDigits: number, maxAbsoluteValue?: number, exactDecimals?: number): string;
+/** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values
+ *      TODO: Support uK, uM and uB suffixes for very small numbers?
+ *      <= 6 characters (<= 5 if positive)
+ */
+export declare function formatNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string;
+export declare function formatBinaryNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string;
+/** YYYY/MM/DD HH:MM:SS PM/AM */
+export declare function formatDateTime(time: number): string;
+export declare function formatDateTimeDetailed(time: number): string;
+export declare function formatFileTimestampLocal(time: number): string;
+/** 2024 January 1, Monday, 12:53:02pm */
+export declare function formatNiceDateTime(time: number): string;
+/** 2024 January 1, Monday, 12:53:02pm (4 months ago)  */
+export declare function formatVeryNiceDateTime(time: number): string;
+/** YYYY/MM/DD */
+export declare function formatDate(time: number): string;
+/** <= 6 characters (<= 5 if positive) */
+export declare function formatPercent(value: number): string;

package/src/formatting/format.ts

@@ -132,7 +132,7 @@ export function formatNumber(count: number | undefined, maxAbsoluteValue?: numbe
 
     maxAbsoluteValue = maxAbsoluteValue ?? Math.abs(count);
 
-    let maxDecimals = noDecimal ? 0 : 3;
+    let maxDecimals = 3;
 
     // NOTE: We don't switch units as soon as we possible can, because...
     //  3.594 vs 3.584 is harder to quickly distinguish compared to 3594 and 3584,
@@ -146,7 +146,23 @@ export function formatNumber(count: number | undefined, maxAbsoluteValue?: numbe
     let divisor = 1;
     let suffix = "";
     let currencyDecimalsNeeded = false;
-    if (maxAbsoluteValue < 1000 * extraFactor) {
+    if (maxAbsoluteValue < 0.00000001) {
+        maxDecimals = 12;
+    } else if (maxAbsoluteValue < 0.0000001) {
+        maxDecimals = 11;
+    } else if (maxAbsoluteValue < 0.000001) {
+        maxDecimals = 10;
+    } else if (maxAbsoluteValue < 0.00001) {
+        maxDecimals = 9;
+    } else if (maxAbsoluteValue < 0.0001) {
+        maxDecimals = 8;
+    } else if (maxAbsoluteValue < 0.001) {
+        maxDecimals = 7;
+    } else if (maxAbsoluteValue < 0.01) {
+        maxDecimals = 6;
+    } else if (maxAbsoluteValue < 0.1) {
+        maxDecimals = 5;
+    } else if (maxAbsoluteValue < 1000 * extraFactor) {
         if (specialCurrency) {
             currencyDecimalsNeeded = true;
         }
@@ -168,6 +184,9 @@ export function formatNumber(count: number | undefined, maxAbsoluteValue?: numbe
     }
     count /= divisor;
     maxAbsoluteValue /= divisor;
+    if (noDecimal) {
+        maxDecimals = 0;
+    }
 
     return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;
 }

package/src/formatting/logColors.d.ts

@@ -0,0 +1,7 @@
+export declare const blue: (text: string) => string;
+export declare const red: (text: string) => string;
+export declare const green: (text: string) => string;
+export declare const yellow: (text: string) => string;
+export declare const white: (text: string) => string;
+export declare const gray: (text: string) => string;
+export declare const magenta: (text: string) => string;

package/src/forwardPort.d.ts

@@ -0,0 +1,5 @@
+export declare function forwardPort(config: {
+    externalPort: number;
+    internalPort: number;
+    duration?: number;
+}): Promise<void>;

package/src/https.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
+    headers?: {
+        [key: string]: string | undefined;
+    };
+    cancel?: Promise<void>;
+}): Promise<Buffer>;

package/src/misc.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { MaybePromise } from "./types";
+export declare const timeInSecond = 1000;
+export declare const timeInMinute: number;
+export declare const timeInHour: number;
+export declare const timeInDay: number;
+export declare const timeInWeek: number;
+export declare const timeInYear: number;
+export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
+export declare function convertErrorStackToError(error: string): Error;
+export declare function sha256Hash(buffer: Buffer | string): string;
+export declare function sha256HashBuffer(buffer: Buffer | string): Buffer;
+/** Async, but works both clientside and serverside. */
+export declare function sha256HashPromise(buffer: Buffer): Promise<any>;
+export declare function sha256BufferPromise(buffer: Buffer): Promise<Buffer>;
+export declare function arrayEqual(a: {
+    [key: number]: unknown;
+    length: number;
+}, b: {
+    [key: number]: unknown;
+    length: number;
+}): boolean;
+export declare function isNode(): boolean;
+export declare function isNodeTrue(): true;
+export declare function formatNumberSuffixed(count: number): string;
+export declare function list(count: number): number[];
+export declare function recursiveFreeze<T>(obj: T): T;
+export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+export declare function isBufferType(obj: unknown): obj is BufferType;
+export declare function getKeys(obj: unknown): PropertyKey[];
+export declare function getStringKeys<T extends {}>(obj: T): ((keyof T) & string)[];
+export declare function keyBy<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T>;
+export declare function keyByArray<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T[]>;
+export declare function deepCloneJSON<T>(obj: T): T;
+export declare class PromiseObj<T = void> {
+    promise: Promise<T>;
+    value: {
+        value?: T;
+        error?: string;
+    } | undefined;
+    /** Resolve called does not mean the value is ready, as it may be resolved with a promise. */
+    resolveCalled?: boolean;
+    resolve: (value: T | Promise<T>) => void;
+    reject: (error: any) => void;
+    private baseResolve;
+    private baseReject;
+    constructor();
+}
+export declare function promiseObj<T = void>(): PromiseObj<T>;
+export declare function throttleFunction<Args extends any[]>(delay: number, fnc: (...args: Args) => MaybePromise<void>): (...args: Args) => Promise<void>;
+export declare function nextId(): string;
+export declare function arrayFromOrderObject<T>(obj: {
+    [order: number]: T;
+}): T[];
+export declare function last<T>(arr: T[]): T | undefined;
+export type ObjectValues<T> = T[keyof T];
+export declare function entries<Obj extends {
+    [key: string]: unknown;
+}>(obj: Obj): [keyof Obj, ObjectValues<Obj>][];
+export declare function keys<Obj extends {
+    [key: string]: unknown;
+}>(obj: Obj): (keyof Obj)[];
+export declare function sort<T>(arr: T[], sortKey: (obj: T) => unknown): T[];
+export declare function getRootDomain(hostname: string): string;
+export declare class QueueLimited<T> {
+    private readonly maxCount;
+    private items;
+    private nextIndex;
+    constructor(maxCount: number);
+    push(item: T): void;
+    getAllUnordered(): T[];
+    reset(): void;
+    clear(): void;
+    getOldest(): T | undefined;
+}
+export declare function binarySearchBasic<T, V>(array: T[], getVal: (val: T) => V, searchValue: V): number;
+export declare function binarySearchBasic2<T, V>(array: T[], getVal: (val: T) => V, searchValue: T): number;
+/**
+ *  Searches indexes, allowing you to query structures that aren't arrays. To search an array, use:
+ *      `binarySearchIndex(array.length, i => compare(array[i], searchValue))`
+ *
+ *      NOTE: If there are duplicates, returns the first match.
+ *
+ *      NOTE: If the value can't be found, returns the bitwise negation of the index where it should be inserted.
+ *
+ *      NOTE: With `if (index < 0) index = ~index;` you will get an index of the value >= the target value.
+ */
+export declare function binarySearchIndex(listCount: number, compare: (lhsIndex: number) => number): number;
+export declare function compare(lhs: unknown, rhs: unknown): number;
+export declare function compareArray(lhs: unknown[], rhs: unknown[]): number;
+export declare function insertIntoSortedList<T>(list: T[], map: (val: T) => string | number, element: T): void;
+export declare function removeFromSortedList<T>(list: T[], map: (val: T) => string | number, searchValue: string | number): void;
+export declare function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error): Promise<T>;
+export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
+export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
+export declare function errorToWarning<T>(promise: Promise<T>): void;

package/src/networking.d.ts

@@ -0,0 +1,11 @@
+export declare const testTCPIsListening: (host: string, port: number) => Promise<boolean>;
+export declare const getExternalIP: {
+    (): Promise<string>;
+    reset(): void;
+    set(newValue: Promise<string>): void;
+};
+export declare const getPublicIP: {
+    (): Promise<string>;
+    reset(): void;
+    set(newValue: Promise<string>): void;
+};

package/src/nodeCache.d.ts

@@ -0,0 +1,24 @@
+import { CallFactory } from "./CallFactory";
+import { MaybePromise } from "./types";
+export declare function getNodeId(domain: string, port: number): string;
+/** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */
+export declare function getNodeIdFromLocation(): string;
+/** A nodeId not available for reconnecting. */
+export declare function getClientNodeId(address: string): string;
+export declare function isClientNodeId(nodeId: string): boolean;
+/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+ *      but we should always have an address).
+ *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
+ *  */
+export declare function getNodeIdIP(nodeId: string): string;
+export declare function getNodeIdLocation(nodeId: string): {
+    address: string;
+    port: number;
+} | undefined;
+export declare function getNodeIdDomain(nodeId: string): string;
+export declare function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined;
+export declare function registerNodeClient(callFactory: CallFactory): void;
+export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
+export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
+export declare function resetAllNodeCallFactories(): void;
+export declare function countOpenConnections(): number;

package/src/nodeProxy.d.ts

@@ -0,0 +1,7 @@
+import { FullCallType, SocketInternalInterface } from "../SocketFunctionTypes";
+type CallProxyType = {
+    [nodeId: string]: SocketInternalInterface;
+};
+export declare const getCallObj: unique symbol;
+export declare function getCallProxy(id: string, callback: (callType: FullCallType) => Promise<unknown>): CallProxyType;
+export {};

package/src/profiling/getOwnTime.d.ts

@@ -0,0 +1,12 @@
+export type OwnTimeObj = {
+    name: string;
+    time: number;
+    ownTime: number;
+};
+export type OwnTimeObjInternal = OwnTimeObj & {
+    lastStartTime: number;
+    firstStartTime: number;
+};
+export declare function getOpenTimesBase(): OwnTimeObjInternal[];
+export declare const measureOverheadTime: number;
+export declare function getOwnTime<T>(name: string, code: () => T, onTime: (obj: OwnTimeObj) => void): T;