devstar插件

node_modules/birpc/dist/index.cjs

@@ -0,0 +1,228 @@
+'use strict';
+
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    off = () => {
+    },
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    bind = "rpc",
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promise;
+  let closed = false;
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      if (method === "$functions")
+        return functions;
+      if (method === "$close")
+        return close;
+      if (method === "$rejectPendingCalls") {
+        return rejectPendingCalls;
+      }
+      if (method === "$closed")
+        return closed;
+      if (method === "then" && !eventNames.includes("then") && !("then" in functions))
+        return void 0;
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: TYPE_REQUEST }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = async (...args) => {
+        if (closed)
+          throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        if (_promise) {
+          try {
+            await _promise;
+          } finally {
+            _promise = void 0;
+          }
+        }
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          let timeoutId;
+          if (timeout >= 0) {
+            timeoutId = setTimeout(() => {
+              try {
+                const handleResult = options.onTimeoutError?.(method, args);
+                if (handleResult !== true)
+                  throw new Error(`[birpc] timeout on calling "${method}"`);
+              } catch (e) {
+                reject(e);
+              }
+              rpcPromiseMap.delete(id);
+            }, timeout);
+            if (typeof timeoutId === "object")
+              timeoutId = timeoutId.unref?.();
+          }
+          rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  function close(customError) {
+    closed = true;
+    rpcPromiseMap.forEach(({ reject, method }) => {
+      const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+      if (customError) {
+        customError.cause ??= error;
+        return reject(customError);
+      }
+      reject(error);
+    });
+    rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  function rejectPendingCalls(handler) {
+    const entries = Array.from(rpcPromiseMap.values());
+    const handlerResults = entries.map(({ method, reject }) => {
+      if (!handler) {
+        return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+      }
+      return handler({ method, reject });
+    });
+    rpcPromiseMap.clear();
+    return handlerResults;
+  }
+  async function onMessage(data, ...extra) {
+    let msg;
+    try {
+      msg = deserialize(data);
+    } catch (e) {
+      if (options.onGeneralError?.(e) !== true)
+        throw e;
+      return;
+    }
+    if (msg.t === TYPE_REQUEST) {
+      const { m: method, a: args } = msg;
+      let result, error;
+      const fn = resolver ? resolver(method, functions[method]) : functions[method];
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(bind === "rpc" ? rpc : functions, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError(error, method, args);
+        if (error && options.onFunctionError) {
+          if (options.onFunctionError(error, method, args) === true)
+            return;
+        }
+        if (!error) {
+          try {
+            post(serialize({ t: TYPE_RESPONSE, i: msg.i, r: result }), ...extra);
+            return;
+          } catch (e) {
+            error = e;
+            if (options.onGeneralError?.(e, method, args) !== true)
+              throw e;
+          }
+        }
+        try {
+          post(serialize({ t: TYPE_RESPONSE, i: msg.i, e: error }), ...extra);
+        } catch (e) {
+          if (options.onGeneralError?.(e, method, args) !== true)
+            throw e;
+        }
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (promise) {
+        clearTimeout(promise.timeoutId);
+        if (error)
+          promise.reject(error);
+        else
+          promise.resolve(result);
+      }
+      rpcPromiseMap.delete(ack);
+    }
+  }
+  _promise = on(onMessage);
+  return rpc;
+}
+const cacheMap = /* @__PURE__ */ new WeakMap();
+function cachedMap(items, fn) {
+  return items.map((i) => {
+    let r = cacheMap.get(i);
+    if (!r) {
+      r = fn(i);
+      cacheMap.set(i, r);
+    }
+    return r;
+  });
+}
+function createBirpcGroup(functions, channels, options = {}) {
+  const getChannels = () => typeof channels === "function" ? channels() : channels;
+  const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, { ...options, ...s }));
+  const broadcastProxy = new Proxy({}, {
+    get(_, method) {
+      const client = getClients();
+      const callbacks = client.map((c) => c[method]);
+      const sendCall = (...args) => {
+        return Promise.all(callbacks.map((i) => i(...args)));
+      };
+      sendCall.asEvent = (...args) => {
+        callbacks.map((i) => i.asEvent(...args));
+      };
+      return sendCall;
+    }
+  });
+  function updateChannels(fn) {
+    const channels2 = getChannels();
+    fn?.(channels2);
+    return getClients(channels2);
+  }
+  getClients();
+  return {
+    get clients() {
+      return getClients();
+    },
+    functions,
+    updateChannels,
+    broadcast: broadcastProxy,
+    /**
+     * @deprecated use `broadcast`
+     */
+    // @ts-expect-error deprecated
+    boardcast: broadcastProxy
+  };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[random() * 64 | 0];
+  return id;
+}
+
+exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.cachedMap = cachedMap;
+exports.createBirpc = createBirpc;
+exports.createBirpcGroup = createBirpcGroup;

node_modules/birpc/dist/index.d.cts

@@ -0,0 +1,124 @@
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Custom function to serialize data
+     *
+     * by default it passes the data as-is
+     */
+    serialize?: (data: any) => any;
+    /**
+     * Custom function to deserialize data
+     *
+     * by default it passes the data as-is
+     */
+    deserialize?: (data: any) => any;
+    /**
+     * Call the methods with the RPC context or the original functions object
+     */
+    bind?: 'rpc' | 'functions';
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     *
+     * @deprecated use `onFunctionError` and `onGeneralError` instead
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred in local functions being called
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred during serialization or messsaging
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+interface BirpcGroupFn<T> {
+    /**
+     * Call the remote function and wait for the result.
+     */
+    (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>[]>;
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+}
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: (error?: Error) => void;
+    $closed: boolean;
+    $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+};
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+type BirpcGroupReturn<RemoteFunctions> = {
+    [K in keyof RemoteFunctions]: BirpcGroupFn<RemoteFunctions[K]>;
+};
+interface BirpcGroup<RemoteFunctions, LocalFunctions = Record<string, never>> {
+    readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions>[];
+    readonly functions: LocalFunctions;
+    readonly broadcast: BirpcGroupReturn<RemoteFunctions>;
+    updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions>[];
+}
+interface PromiseEntry {
+    resolve: (arg: any) => void;
+    reject: (error: any) => void;
+    method: string;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const DEFAULT_TIMEOUT = 60000;
+declare const setTimeout: typeof globalThis.setTimeout;
+declare function createBirpc<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, options: BirpcOptions<RemoteFunctions>): BirpcReturn<RemoteFunctions, LocalFunctions>;
+declare function cachedMap<T, R>(items: T[], fn: ((i: T) => R)): R[];
+declare function createBirpcGroup<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, channels: ChannelOptions[] | (() => ChannelOptions[]), options?: EventOptions<RemoteFunctions>): BirpcGroup<RemoteFunctions, LocalFunctions>;
+
+export { type ArgumentsType, type BirpcFn, type BirpcGroup, type BirpcGroupFn, type BirpcGroupReturn, type BirpcOptions, type BirpcResolver, type BirpcReturn, type ChannelOptions, DEFAULT_TIMEOUT, type EventOptions, type PromisifyFn, type ReturnType, cachedMap, createBirpc, createBirpcGroup };

node_modules/birpc/dist/index.d.mts

@@ -0,0 +1,124 @@
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Custom function to serialize data
+     *
+     * by default it passes the data as-is
+     */
+    serialize?: (data: any) => any;
+    /**
+     * Custom function to deserialize data
+     *
+     * by default it passes the data as-is
+     */
+    deserialize?: (data: any) => any;
+    /**
+     * Call the methods with the RPC context or the original functions object
+     */
+    bind?: 'rpc' | 'functions';
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     *
+     * @deprecated use `onFunctionError` and `onGeneralError` instead
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred in local functions being called
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred during serialization or messsaging
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+interface BirpcGroupFn<T> {
+    /**
+     * Call the remote function and wait for the result.
+     */
+    (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>[]>;
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+}
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: (error?: Error) => void;
+    $closed: boolean;
+    $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+};
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+type BirpcGroupReturn<RemoteFunctions> = {
+    [K in keyof RemoteFunctions]: BirpcGroupFn<RemoteFunctions[K]>;
+};
+interface BirpcGroup<RemoteFunctions, LocalFunctions = Record<string, never>> {
+    readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions>[];
+    readonly functions: LocalFunctions;
+    readonly broadcast: BirpcGroupReturn<RemoteFunctions>;
+    updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions>[];
+}
+interface PromiseEntry {
+    resolve: (arg: any) => void;
+    reject: (error: any) => void;
+    method: string;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const DEFAULT_TIMEOUT = 60000;
+declare const setTimeout: typeof globalThis.setTimeout;
+declare function createBirpc<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, options: BirpcOptions<RemoteFunctions>): BirpcReturn<RemoteFunctions, LocalFunctions>;
+declare function cachedMap<T, R>(items: T[], fn: ((i: T) => R)): R[];
+declare function createBirpcGroup<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, channels: ChannelOptions[] | (() => ChannelOptions[]), options?: EventOptions<RemoteFunctions>): BirpcGroup<RemoteFunctions, LocalFunctions>;
+
+export { type ArgumentsType, type BirpcFn, type BirpcGroup, type BirpcGroupFn, type BirpcGroupReturn, type BirpcOptions, type BirpcResolver, type BirpcReturn, type ChannelOptions, DEFAULT_TIMEOUT, type EventOptions, type PromisifyFn, type ReturnType, cachedMap, createBirpc, createBirpcGroup };

node_modules/birpc/dist/index.d.ts

@@ -0,0 +1,124 @@
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Custom function to serialize data
+     *
+     * by default it passes the data as-is
+     */
+    serialize?: (data: any) => any;
+    /**
+     * Custom function to deserialize data
+     *
+     * by default it passes the data as-is
+     */
+    deserialize?: (data: any) => any;
+    /**
+     * Call the methods with the RPC context or the original functions object
+     */
+    bind?: 'rpc' | 'functions';
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     *
+     * @deprecated use `onFunctionError` and `onGeneralError` instead
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred in local functions being called
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred during serialization or messsaging
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+interface BirpcGroupFn<T> {
+    /**
+     * Call the remote function and wait for the result.
+     */
+    (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>[]>;
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+}
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: (error?: Error) => void;
+    $closed: boolean;
+    $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+};
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+type BirpcGroupReturn<RemoteFunctions> = {
+    [K in keyof RemoteFunctions]: BirpcGroupFn<RemoteFunctions[K]>;
+};
+interface BirpcGroup<RemoteFunctions, LocalFunctions = Record<string, never>> {
+    readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions>[];
+    readonly functions: LocalFunctions;
+    readonly broadcast: BirpcGroupReturn<RemoteFunctions>;
+    updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions>[];
+}
+interface PromiseEntry {
+    resolve: (arg: any) => void;
+    reject: (error: any) => void;
+    method: string;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const DEFAULT_TIMEOUT = 60000;
+declare const setTimeout: typeof globalThis.setTimeout;
+declare function createBirpc<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, options: BirpcOptions<RemoteFunctions>): BirpcReturn<RemoteFunctions, LocalFunctions>;
+declare function cachedMap<T, R>(items: T[], fn: ((i: T) => R)): R[];
+declare function createBirpcGroup<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, channels: ChannelOptions[] | (() => ChannelOptions[]), options?: EventOptions<RemoteFunctions>): BirpcGroup<RemoteFunctions, LocalFunctions>;
+
+export { type ArgumentsType, type BirpcFn, type BirpcGroup, type BirpcGroupFn, type BirpcGroupReturn, type BirpcOptions, type BirpcResolver, type BirpcReturn, type ChannelOptions, DEFAULT_TIMEOUT, type EventOptions, type PromisifyFn, type ReturnType, cachedMap, createBirpc, createBirpcGroup };

node_modules/birpc/dist/index.mjs

@@ -0,0 +1,223 @@
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    off = () => {
+    },
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    bind = "rpc",
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promise;
+  let closed = false;
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      if (method === "$functions")
+        return functions;
+      if (method === "$close")
+        return close;
+      if (method === "$rejectPendingCalls") {
+        return rejectPendingCalls;
+      }
+      if (method === "$closed")
+        return closed;
+      if (method === "then" && !eventNames.includes("then") && !("then" in functions))
+        return void 0;
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: TYPE_REQUEST }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = async (...args) => {
+        if (closed)
+          throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        if (_promise) {
+          try {
+            await _promise;
+          } finally {
+            _promise = void 0;
+          }
+        }
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          let timeoutId;
+          if (timeout >= 0) {
+            timeoutId = setTimeout(() => {
+              try {
+                const handleResult = options.onTimeoutError?.(method, args);
+                if (handleResult !== true)
+                  throw new Error(`[birpc] timeout on calling "${method}"`);
+              } catch (e) {
+                reject(e);
+              }
+              rpcPromiseMap.delete(id);
+            }, timeout);
+            if (typeof timeoutId === "object")
+              timeoutId = timeoutId.unref?.();
+          }
+          rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  function close(customError) {
+    closed = true;
+    rpcPromiseMap.forEach(({ reject, method }) => {
+      const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+      if (customError) {
+        customError.cause ??= error;
+        return reject(customError);
+      }
+      reject(error);
+    });
+    rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  function rejectPendingCalls(handler) {
+    const entries = Array.from(rpcPromiseMap.values());
+    const handlerResults = entries.map(({ method, reject }) => {
+      if (!handler) {
+        return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+      }
+      return handler({ method, reject });
+    });
+    rpcPromiseMap.clear();
+    return handlerResults;
+  }
+  async function onMessage(data, ...extra) {
+    let msg;
+    try {
+      msg = deserialize(data);
+    } catch (e) {
+      if (options.onGeneralError?.(e) !== true)
+        throw e;
+      return;
+    }
+    if (msg.t === TYPE_REQUEST) {
+      const { m: method, a: args } = msg;
+      let result, error;
+      const fn = resolver ? resolver(method, functions[method]) : functions[method];
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(bind === "rpc" ? rpc : functions, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError(error, method, args);
+        if (error && options.onFunctionError) {
+          if (options.onFunctionError(error, method, args) === true)
+            return;
+        }
+        if (!error) {
+          try {
+            post(serialize({ t: TYPE_RESPONSE, i: msg.i, r: result }), ...extra);
+            return;
+          } catch (e) {
+            error = e;
+            if (options.onGeneralError?.(e, method, args) !== true)
+              throw e;
+          }
+        }
+        try {
+          post(serialize({ t: TYPE_RESPONSE, i: msg.i, e: error }), ...extra);
+        } catch (e) {
+          if (options.onGeneralError?.(e, method, args) !== true)
+            throw e;
+        }
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (promise) {
+        clearTimeout(promise.timeoutId);
+        if (error)
+          promise.reject(error);
+        else
+          promise.resolve(result);
+      }
+      rpcPromiseMap.delete(ack);
+    }
+  }
+  _promise = on(onMessage);
+  return rpc;
+}
+const cacheMap = /* @__PURE__ */ new WeakMap();
+function cachedMap(items, fn) {
+  return items.map((i) => {
+    let r = cacheMap.get(i);
+    if (!r) {
+      r = fn(i);
+      cacheMap.set(i, r);
+    }
+    return r;
+  });
+}
+function createBirpcGroup(functions, channels, options = {}) {
+  const getChannels = () => typeof channels === "function" ? channels() : channels;
+  const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, { ...options, ...s }));
+  const broadcastProxy = new Proxy({}, {
+    get(_, method) {
+      const client = getClients();
+      const callbacks = client.map((c) => c[method]);
+      const sendCall = (...args) => {
+        return Promise.all(callbacks.map((i) => i(...args)));
+      };
+      sendCall.asEvent = (...args) => {
+        callbacks.map((i) => i.asEvent(...args));
+      };
+      return sendCall;
+    }
+  });
+  function updateChannels(fn) {
+    const channels2 = getChannels();
+    fn?.(channels2);
+    return getClients(channels2);
+  }
+  getClients();
+  return {
+    get clients() {
+      return getClients();
+    },
+    functions,
+    updateChannels,
+    broadcast: broadcastProxy,
+    /**
+     * @deprecated use `broadcast`
+     */
+    // @ts-expect-error deprecated
+    boardcast: broadcastProxy
+  };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[random() * 64 | 0];
+  return id;
+}
+
+export { DEFAULT_TIMEOUT, cachedMap, createBirpc, createBirpcGroup };