osra 0.0.10 → 0.0.12

package/build/call.d.ts

@@ -9,3 +9,9 @@ export declare const call: <T2 extends Resolvers>(target: Target, { key }?: {
  * Make a listener for a call
  */
 export declare const makeCallListener: <T extends (data: any, extra: ApiResolverOptions) => unknown>(func: T) => T;
+/**
+ * Make a listener for a call
+ */
+export declare const makeProxyCallListener: <T extends (data: any, extra: ApiResolverOptions) => unknown>(target: Target, { key }?: {
+    key?: string | undefined;
+}) => T;

package/build/index.d.ts

@@ -2,3 +2,5 @@ import type { ApiMessageData, ApiResolverOptions, Resolvers, StructuredCloneTran
 export type { ApiMessageData, ApiResolverOptions, Resolvers, StructuredCloneTransferableObject, StructuredCloneTransferableType, StructuredCloneObject, StructuredCloneType, Target, TransferableObject };
 export * from './register';
 export * from './call';
+export * from './webextension';
+export * from './utils';

package/build/index.js

@@ -1,89 +1,222 @@
-const m = "osra-message", A = ({
-  target: r,
-  resolvers: s,
-  filter: o,
-  map: t,
-  key: n = m
-}) => {
-  const a = (e) => {
-    if (!e.data || typeof e.data != "object" || e.data?.source !== n || o && !o(e))
-      return;
-    const { type: c, data: b, port: g } = e.data, i = s[c];
-    if (!i)
-      throw new Error(`Osra received a message of type "${String(c)}" but no resolver was found for type.`);
-    t ? i(...t(b, { event: e, type: c, port: g })) : i(b, { event: e, type: c, port: g });
-  };
-  return r.addEventListener("message", a), {
-    listener: a,
-    resolvers: s
-  };
-}, y = (r) => !!(globalThis.SharedArrayBuffer && r instanceof globalThis.SharedArrayBuffer), h = (r) => globalThis.ArrayBuffer && r instanceof globalThis.ArrayBuffer || globalThis.MessagePort && r instanceof globalThis.MessagePort || globalThis.ReadableStream && r instanceof globalThis.ReadableStream || globalThis.WritableStream && r instanceof globalThis.WritableStream || globalThis.TransformStream && r instanceof globalThis.TransformStream ? !0 : !!(globalThis.ImageBitmap && r instanceof globalThis.ImageBitmap), p = (r) => {
-  const s = [], o = (t) => y(t) ? void 0 : h(t) ? s.push(t) : Array.isArray(t) ? t.map(o) : t && typeof t == "object" ? Object.values(t).map(o) : void 0;
-  return o(r), s;
-}, l = "__proxyFunctionPort__", O = (r) => {
-  const { port1: s, port2: o } = new MessageChannel();
-  return s.addEventListener("message", async (t) => {
+const f = "osra-message", P = (t) => !!(globalThis.SharedArrayBuffer && t instanceof globalThis.SharedArrayBuffer), h = (t) => globalThis.ArrayBuffer && t instanceof globalThis.ArrayBuffer || globalThis.MessagePort && t instanceof globalThis.MessagePort || globalThis.ReadableStream && t instanceof globalThis.ReadableStream || globalThis.WritableStream && t instanceof globalThis.WritableStream || globalThis.TransformStream && t instanceof globalThis.TransformStream ? !0 : !!(globalThis.ImageBitmap && t instanceof globalThis.ImageBitmap), b = (t) => {
+  const e = [], s = (r) => P(r) ? void 0 : h(r) ? e.push(r) : Array.isArray(r) ? r.map(s) : r && typeof r == "object" ? Object.values(r).map(s) : void 0;
+  return s(t), e;
+}, p = "__proxyFunctionPort__", L = "__proxyMessageChannelPort__", A = (t) => {
+  const { port1: e, port2: s } = new MessageChannel();
+  return e.addEventListener("message", async (r) => {
     try {
-      const n = await r(...t.data), a = f(n), e = p(a);
-      s.postMessage({ result: a }, { transfer: e });
-    } catch (n) {
-      s.postMessage({ error: n });
+      const a = await t(...r.data), n = m(a), o = b(n);
+      e.postMessage({ result: n }, { transfer: o });
+    } catch (a) {
+      e.postMessage({ error: a });
     }
-  }), s.start(), o;
-}, f = (r) => y(r) || h(r) ? r : typeof r == "function" ? { [l]: O(r) } : Array.isArray(r) ? r.map(f) : r && typeof r == "object" ? Object.fromEntries(
-  Object.entries(r).map(([s, o]) => [
-    s,
-    f(o)
+  }), e.start(), s;
+}, m = (t) => P(t) || h(t) ? t : typeof t == "function" ? { [p]: A(t) } : Array.isArray(t) ? t.map(m) : t && typeof t == "object" ? Object.fromEntries(
+  Object.entries(t).map(([e, s]) => [
+    e,
+    m(s)
   ])
-) : r, j = (r) => (...s) => new Promise((o, t) => {
-  const n = f(s), a = p(n);
-  r.addEventListener("message", (e) => {
-    e.data.error ? t(e.data.error) : o(d(e.data.result));
-  }), r.start(), r.postMessage(n, { transfer: a });
-}), d = (r) => y(r) || h(r) ? r : r && typeof r == "object" && r[l] ? j(r[l]) : Array.isArray(r) ? r.map(f) : r && typeof r == "object" ? Object.fromEntries(
-  Object.entries(r).map(([s, o]) => [
-    s,
-    d(o)
+) : t, _ = (t) => (...e) => new Promise((s, r) => {
+  const a = m(e), n = b(a), o = (c) => {
+    c.data.error ? r(c.data.error) : s(M(c.data.result)), t.removeEventListener("message", o);
+  };
+  t.addEventListener("message", o), t.start(), t.postMessage(a, { transfer: n });
+}), M = (t) => P(t) || h(t) ? t : t && typeof t == "object" && t[p] ? _(t[p]) : Array.isArray(t) ? t.map(m) : t && typeof t == "object" ? Object.fromEntries(
+  Object.entries(t).map(([e, s]) => [
+    e,
+    M(s)
   ])
-) : r, E = (r, { key: s = m } = { key: m }) => (o, t) => new Promise((n, a) => {
-  const { port1: e, port2: c } = new MessageChannel();
-  e.addEventListener(
+) : t, C = ({
+  target: t,
+  resolvers: e,
+  filter: s,
+  map: r,
+  key: a = f,
+  proxyTarget: n
+}) => {
+  const o = (c) => {
+    if (!c.data || typeof c.data != "object" || c.data?.source !== a || s && !s(c))
+      return;
+    if (n) {
+      const { type: l, data: O, port: T } = c.data, x = b(O);
+      n.postMessage(
+        {
+          source: a,
+          type: l,
+          data: O,
+          port: T
+        },
+        {
+          targetOrigin: "*",
+          transfer: [T, ...x ?? []]
+        }
+      );
+      return;
+    }
+    const { type: i, data: d, port: g } = c.data, y = e[i];
+    if (!y)
+      throw new Error(`Osra received a message of type "${String(i)}" but no resolver was found for type.`);
+    r ? y(...r(d, { event: c, type: i, port: g })) : y(d, { event: c, type: i, port: g });
+  };
+  return t.addEventListener("message", o), {
+    listener: o,
+    resolvers: e
+  };
+}, R = (t, { key: e = f } = { key: f }) => (s, r) => new Promise((a, n) => {
+  const { port1: o, port2: c } = new MessageChannel();
+  o.addEventListener(
     "message",
-    ({ data: i }) => {
-      if (i.error)
-        a(i.error);
+    ({ data: g }) => {
+      if (g.error)
+        n(g.error);
       else {
-        const T = d(i.result);
-        n(T);
+        const y = M(g.result);
+        a(y);
       }
-      e.close(), c.close();
+      o.close(), c.close();
     },
     { once: !0 }
-  ), e.start();
-  const b = f(t), g = p(b);
-  r.postMessage(
+  ), o.start();
+  const i = m(r), d = b(i);
+  t.postMessage(
     {
-      source: s,
-      type: o,
-      data: b,
+      source: e,
+      type: s,
+      data: i,
       port: c
     },
     {
       targetOrigin: "*",
-      transfer: [c, ...g ?? []]
+      transfer: [c, ...d ?? []]
     }
   );
-}), S = (r) => async (s, o) => {
-  const { port: t } = o, n = d(s);
+}), D = (t) => async (e, s) => {
+  const { port: r } = s, a = M(e);
   try {
-    const a = await r(n, o), e = f(a), c = p(e);
-    return t.postMessage({ result: e }, { transfer: c }), t.close(), a;
-  } catch (a) {
-    throw t.postMessage({ error: a }), t.close(), a;
+    const n = await t(a, s), o = m(n), c = b(o);
+    return r.postMessage({ result: o }, { transfer: c }), r.close(), n;
+  } catch (n) {
+    throw r.postMessage({ error: n }), r.close(), n;
   }
+}, $ = (t, { key: e = f } = { key: f }) => (s, r) => {
+  const { type: a, port: n } = r, o = b(s);
+  t.postMessage(
+    {
+      source: e,
+      type: a,
+      data: s,
+      port: n
+    },
+    {
+      targetOrigin: "*",
+      transfer: [n, ...o ?? []]
+    }
+  );
+}, j = ({ key: t = f }) => {
+  const e = /* @__PURE__ */ new Map(), s = async (a) => e.get(a) ?? new Promise((n, o) => {
+    let c = !1;
+    setTimeout(() => {
+      c || o(new Error(`Osra getPort for "${a}" timed out`));
+    }, 1e3), chrome.runtime.onConnect.addListener((i) => {
+      i.name === `${t}:${a}` && (e.set(a, i), n(i), c = !0);
+    });
+  }), r = {
+    addPort: (a, n) => e.set(a, n),
+    proxyPort: (a) => {
+      const n = self.crypto.randomUUID(), o = chrome.runtime.connect({ name: `${t}:${n}` });
+      return e.set(n, o), o.onDisconnect.addListener(() => {
+        e.delete(n);
+      }), o.onMessage.addListener((c) => {
+        a.postMessage(c);
+      }), a.addEventListener("message", async (c) => {
+        o.postMessage(c.data);
+      }), a.addEventListener("close", () => {
+        o.disconnect();
+      }), {
+        [L]: n
+      };
+    },
+    proxiedPort: async ({ [L]: a }) => {
+      const { port1: n, port2: o } = new MessageChannel(), c = await s(a);
+      c.onMessage.addListener((d) => {
+        n.postMessage(d);
+      }), c.onDisconnect.addListener(() => {
+        n.close();
+      }), n.addEventListener("close", () => {
+        c.disconnect();
+      }), n.addEventListener("message", async (d) => {
+        c.postMessage(d.data);
+      }), n.start(), o.addEventListener("message", async (d) => {
+        c.postMessage(d.data);
+      }), o.start();
+      const i = S(r, o);
+      return i.uuid = a, i;
+    }
+  };
+  return r;
+}, E = (t, e) => e instanceof MessagePort ? t.proxyPort(e) : P(e) || h(e) ? e : typeof e == "object" && p in e ? { [p]: t.proxyPort(e[p]) } : Array.isArray(e) ? e.map((s) => E(t, s)) : e && typeof e == "object" ? Object.fromEntries(
+  Object.entries(e).map(([s, r]) => [
+    s,
+    E(t, r)
+  ])
+) : e, w = async (t, e) => P(e) || h(e) ? e : typeof e == "object" && L in e ? await t.proxiedPort(e) : typeof e == "object" && p in e ? { [p]: await t.proxiedPort(e[p]) } : Array.isArray(e) ? await Promise.all(e.map((s) => w(t, s))) : e && typeof e == "object" ? Object.fromEntries(
+  await Promise.all(
+    Object.entries(e).map(async ([s, r]) => [
+      s,
+      await w(t, r)
+    ])
+  )
+) : e, S = (t, e) => {
+  const s = e.postMessage;
+  return e.postMessage = (r) => {
+    s.apply(e, [E(t, r)]);
+  }, e;
+}, B = ({
+  target: t,
+  key: e = f
+}) => {
+  const s = j({ key: e });
+  return {
+    ...t,
+    postMessage: (r) => {
+      t.runtime.sendMessage(E(s, r));
+    }
+  };
+}, F = ({
+  target: t,
+  key: e = f
+}) => {
+  const s = j({ key: e });
+  return {
+    ...t,
+    addEventListener: (r, a, n) => {
+      if (r !== "message")
+        return t.addEventListener(r, a, n);
+      chrome.runtime.onMessage.addListener((o, c, i) => {
+        w(s, o).then((d) => a({ data: d }));
+      }), chrome.runtime.onConnect.addListener((o) => {
+        o.name.startsWith(`${e}:`) && s.addPort(o.name.split(":")[1], o);
+      });
+    }
+  };
 };
 export {
-  E as call,
-  S as makeCallListener,
-  A as registerListener
+  p as PROXY_FUNCTION_PROPERTY,
+  L as PROXY_MESSAGE_CHANNEL_PROPERTY,
+  R as call,
+  b as getTransferableObjects,
+  P as isClonable,
+  h as isTransferable,
+  D as makeCallListener,
+  M as makeObjectProxiedFunctions,
+  _ as makeProxiedFunction,
+  $ as makeProxyCallListener,
+  A as makeProxyFunction,
+  m as proxyObjectFunctions,
+  C as registerListener,
+  w as replaceProxied,
+  E as replaceProxies,
+  B as wrapExtensionTarget,
+  F as wrapListenerExtensionTarget,
+  S as wrapPort
 };

package/build/register.d.ts

@@ -1,5 +1,5 @@
-import type { ApiMessageData, ApiResolverOptions, Resolvers, ValidateResolvers } from './types';
-export declare const registerListener: <T extends Record<PropertyKey, (data: any, extra: ApiResolverOptions) => unknown>>({ target, resolvers, filter, map, key }: {
+import type { ApiMessageData, ApiResolverOptions, Resolvers, Target, ValidateResolvers } from './types';
+export declare const registerListener: <T extends Record<PropertyKey, (data: any, extra: ApiResolverOptions) => unknown>>({ target, resolvers, filter, map, key, proxyTarget }: {
     target: WindowEventHandlers | ServiceWorkerContainer | Worker | SharedWorker;
     resolvers: ValidateResolvers<T>;
     filter?: ((event: MessageEvent<any>) => boolean) | undefined;
@@ -13,6 +13,7 @@ export declare const registerListener: <T extends Record<PropertyKey, (data: any
         port: MessagePort;
     }]) | undefined;
     key?: string | undefined;
+    proxyTarget?: Target | undefined;
 }) => {
     listener: (event: MessageEvent<ApiMessageData<Resolvers>>) => void;
     resolvers: ValidateResolvers<T>;

package/build/types.d.ts

@@ -8,7 +8,7 @@ export type StructuredCloneTransferableObject = {
 };
 export type ProxiedType = (...args: StructuredCloneTransferableType[]) => StructuredCloneTransferableType | Promise<StructuredCloneTransferableType>;
 export type StructuredCloneTransferableType = StructuredCloneType | TransferableObject | Array<StructuredCloneTransferableType> | StructuredCloneTransferableObject | Map<StructuredCloneTransferableType, StructuredCloneTransferableType> | Set<StructuredCloneTransferableType> | ProxiedType;
-export type Target = Window | ServiceWorker | Worker;
+export type Target = Window | ServiceWorker | Worker | MessagePort;
 type NormalizeRecord<T> = T extends Record<any, any> ? {
     [K in keyof T]: NormalizeRecord<T[K]>;
 } : T;

package/build/utils.d.ts

@@ -1,5 +1,9 @@
 import { TransferableObject } from './types';
+export declare const isClonable: (value: any) => boolean;
+export declare const isTransferable: (value: any) => boolean;
 export declare const getTransferableObjects: (value: any) => TransferableObject[];
+export declare const PROXY_FUNCTION_PROPERTY = "__proxyFunctionPort__";
+export declare const PROXY_MESSAGE_CHANNEL_PROPERTY = "__proxyMessageChannelPort__";
 export declare const makeProxyFunction: (func: any) => MessagePort;
 export declare const proxyObjectFunctions: (value: any) => any;
 export declare const makeProxiedFunction: (port: MessagePort) => (...args: any[]) => Promise<unknown>;

package/build/webextension.d.ts

@@ -0,0 +1,137 @@
+import type browser from 'webextension-polyfill';
+import { PROXY_MESSAGE_CHANNEL_PROPERTY } from './utils';
+type PortManager = ReturnType<typeof makePortManager>;
+declare const makePortManager: ({ key }: {
+    key?: string | undefined;
+}) => {
+    addPort: (name: string, port: browser.Runtime.Port) => Map<string, browser.Runtime.Port>;
+    proxyPort: (messagePort: MessagePort) => {
+        __proxyMessageChannelPort__: string;
+    };
+    proxiedPort: ({ [PROXY_MESSAGE_CHANNEL_PROPERTY]: uuid }: {
+        [PROXY_MESSAGE_CHANNEL_PROPERTY]: string;
+    }) => Promise<MessagePort>;
+};
+export declare const replaceProxies: (portManager: PortManager, value: any) => any;
+export declare const replaceProxied: (portManager: PortManager, value: any) => any;
+export declare const wrapPort: (portManager: any, port: MessagePort) => MessagePort;
+export declare const wrapExtensionTarget: ({ target, key }: {
+    target: browser.Browser;
+    key?: string | undefined;
+}) => {
+    postMessage: (message: any) => void;
+    activityLog: browser.ActivityLog.Static;
+    alarms: browser.Alarms.Static;
+    bookmarks: browser.Bookmarks.Static;
+    action: browser.Action.Static;
+    browserAction: browser.BrowserAction.Static;
+    browserSettings: browser.BrowserSettings.Static;
+    browsingData: browser.BrowsingData.Static;
+    captivePortal: browser.CaptivePortal.Static;
+    clipboard: browser.Clipboard.Static;
+    commands: browser.Commands.Static;
+    contentScripts: browser.ContentScripts.Static;
+    contextualIdentities: browser.ContextualIdentities.Static;
+    cookies: browser.Cookies.Static;
+    declarativeNetRequest: browser.DeclarativeNetRequest.Static;
+    devtools: browser.Devtools.Static;
+    dns: browser.Dns.Static;
+    downloads: browser.Downloads.Static;
+    events: browser.Events.Static;
+    experiments: browser.Experiments.Static;
+    extension: browser.Extension.Static;
+    extensionTypes: browser.ExtensionTypes.Static;
+    find: browser.Find.Static;
+    geckoProfiler: browser.GeckoProfiler.Static;
+    history: browser.History.Static;
+    i18n: browser.I18n.Static;
+    identity: browser.Identity.Static;
+    idle: browser.Idle.Static;
+    management: browser.Management.Static;
+    manifest: browser.Manifest.Static;
+    contextMenus: browser.ContextMenus.Static;
+    menus: browser.Menus.Static;
+    networkStatus: browser.NetworkStatus.Static;
+    normandyAddonStudy: browser.NormandyAddonStudy.Static;
+    notifications: browser.Notifications.Static;
+    omnibox: browser.Omnibox.Static;
+    pageAction: browser.PageAction.Static;
+    permissions: browser.Permissions.Static;
+    pkcs11: browser.Pkcs11.Static;
+    privacy: browser.Privacy.Static;
+    proxy: browser.Proxy.Static;
+    runtime: browser.Runtime.Static;
+    scripting: browser.Scripting.Static;
+    search: browser.Search.Static;
+    sessions: browser.Sessions.Static;
+    sidebarAction: browser.SidebarAction.Static;
+    storage: browser.Storage.Static;
+    tabs: browser.Tabs.Static;
+    theme: browser.Theme.Static;
+    topSites: browser.TopSites.Static;
+    types: browser.Types.Static;
+    urlbar: browser.Urlbar.Static;
+    userScripts: browser.UserScripts.Static;
+    webNavigation: browser.WebNavigation.Static;
+    webRequest: browser.WebRequest.Static;
+    windows: browser.Windows.Static;
+};
+export declare const wrapListenerExtensionTarget: ({ target, key }: {
+    target: WindowEventHandlers | ServiceWorkerContainer | Worker | SharedWorker;
+    key?: string | undefined;
+}) => {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
+    ongamepadconnected: ((this: WindowEventHandlers, ev: GamepadEvent) => any) | null;
+    ongamepaddisconnected: ((this: WindowEventHandlers, ev: GamepadEvent) => any) | null;
+    onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
+    onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onmessage: ((this: WindowEventHandlers, ev: MessageEvent<any>) => any) | null;
+    onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent<any>) => any) | null;
+    onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
+    onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
+    onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
+    onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
+    onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
+    onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
+    onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+} | {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    controller: ServiceWorker | null;
+    oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
+    onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent<any>) => any) | null;
+    onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent<any>) => any) | null;
+    ready: Promise<ServiceWorkerRegistration>;
+    getRegistration(clientURL?: string | URL | undefined): Promise<ServiceWorkerRegistration | undefined>;
+    getRegistrations(): Promise<readonly ServiceWorkerRegistration[]>;
+    register(scriptURL: string | URL, options?: RegistrationOptions | undefined): Promise<ServiceWorkerRegistration>;
+    startMessages(): void;
+    removeEventListener<K_1 extends keyof ServiceWorkerContainerEventMap>(type: K_1, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+} | {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    port: MessagePort;
+    removeEventListener<K_2 extends "error">(type: K_2, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K_2]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+    onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+} | {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null;
+    onmessageerror: ((this: Worker, ev: MessageEvent<any>) => any) | null;
+    postMessage(message: any, transfer: Transferable[]): void;
+    postMessage(message: any, options?: StructuredSerializeOptions | undefined): void;
+    terminate(): void;
+    removeEventListener<K_3 extends keyof WorkerEventMap>(type: K_3, listener: (this: Worker, ev: WorkerEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+    onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osra",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Easy communication between workers",
   "files": [
     "build"
@@ -31,7 +31,9 @@
   "homepage": "https://github.com/Banou26/osra#readme",
   "devDependencies": {
     "@types/chai-as-promised": "^7.1.5",
+    "@types/chrome": "^0.0.237",
     "@types/node": "^18.11.18",
+    "@types/webextension-polyfill": "^0.10.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "concurrently": "^7.0.0",
@@ -39,6 +41,7 @@
     "epk": "^0.16.0",
     "mime": "^3.0.0",
     "typescript": "^4.9.4",
-    "vite": "^4.0.4"
+    "vite": "^4.0.4",
+    "webextension-polyfill": "^0.10.0"
   }
 }