reflected 0.2.5 → 0.2.6

package/dist/proxy/main/async-8J3q5T6q.js

@@ -0,0 +1,41 @@
+import { w as withResolvers, b as byteOffset, i as identity } from './shared-CV7CPYuP.js';
+import { s as sender, d as decoder } from './sender-Dkjjbv2Y.js';
+import { i as i32 } from './i32-UV5fM9Tw.js';
+import './channel-NcnPEVL4.js';
+
+const { promise, resolve } = withResolvers();
+
+addEventListener(
+  'message',
+  ({ data: [_, main, channel] }) => resolve([main, channel]),
+  { once: true }
+);
+
+const channel = 'async';
+
+const handle = (channel, options) => {
+  const bc = new BroadcastChannel(channel);
+  const next = i32();
+  const decode = (options.decoder ?? decoder)({ byteOffset });
+  const onsync = options.onsync ?? identity;
+  const map = new Map;
+  bc.addEventListener('message', ({ data: [id, { length, buffer }] }) => {
+    map.get(id)(onsync(length ? decode(length, buffer) : void 0));
+    map.delete(id);
+  });
+  return (payload, ...rest) => {
+    const { promise, resolve } = withResolvers();
+    const id = next();
+    map.set(id, resolve);
+    // @ts-ignore
+    bc.postMessage([id, payload], ...rest);
+    return promise;
+  };
+};
+
+var async = options => promise.then(([main, channel]) => {
+  postMessage(1);
+  return handle(channel, sender({ ...main, ...options }));
+});
+
+export { channel, async as default };

package/dist/proxy/main/async-Di4MuQWe.js

@@ -0,0 +1,44 @@
+import { b as bootstrap, S as Sender, h as handler, u as url, p as post } from './shared-DdPca9Ke.js';
+import { S as SAB$1 } from './shared-array-buffer-BQgQXQvC.js';
+import { b as byteOffset, r as randomUUID } from './shared-CV7CPYuP.js';
+
+var SAB = ({
+  initByteLength = 1024,
+  maxByteLength = (1024 * 8)
+}) =>
+  new SAB$1(
+    byteOffset + initByteLength,
+    { maxByteLength: byteOffset + maxByteLength }
+  );
+
+const CHANNEL = 'async';
+
+let Worker$1 = class Worker extends Sender {
+  constructor(scriptURL, options, resolve) {
+    const channel = randomUUID();
+    const bc = new BroadcastChannel(channel);
+    const sab = SAB(options);
+    const i32a = new Int32Array(sab);
+    const handle = handler(sab, options, false);
+    bc.addEventListener('message', async ({ data: [id, payload] }) => {
+      await handle({ data: payload });
+      bc.postMessage([id, new Uint8Array(sab, byteOffset, i32a[1])]);
+    });
+    super(...url(scriptURL, CHANNEL, options));
+    super.addEventListener('message', () => resolve(this), { once: true });
+    super.postMessage(post(sab, options).concat(channel));
+  }
+
+  get channel() {
+    return CHANNEL;
+  }
+};
+var async = bootstrap(Worker$1);
+
+var async$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Worker: Worker$1,
+  default: async
+});
+
+export { SAB as S, Worker$1 as W, async$1 as a };

package/dist/proxy/main/broadcast-CR8vlkKk.js

@@ -0,0 +1,24 @@
+import { b as bootstrap, S as Sender, a as SAB, h as handler, u as url, p as post } from './shared-DdPca9Ke.js';
+import { r as randomUUID } from './shared-CV7CPYuP.js';
+import './i32-UV5fM9Tw.js';
+import './channel-NcnPEVL4.js';
+
+const CHANNEL = 'broadcast';
+
+var broadcast = bootstrap(class Worker extends Sender {
+  constructor(scriptURL, options, resolve) {
+    const channel = randomUUID();
+    const bc = new BroadcastChannel(channel);
+    const sab = SAB(options);
+    bc.addEventListener('message', handler(sab, options, true));
+    super(...url(scriptURL, CHANNEL, options));
+    super.addEventListener('message', () => resolve(this), { once: true });
+    super.postMessage(post(sab, options).concat(channel));
+  }
+
+  get channel() {
+    return CHANNEL;
+  }
+});
+
+export { broadcast as default };

package/dist/proxy/main/broadcast-LNW6nFVD.js

@@ -0,0 +1,15 @@
+import { w as withResolvers } from './shared-CV7CPYuP.js';
+import { h as handler } from './shared-C3U1MNPd.js';
+import './sender-Dkjjbv2Y.js';
+import './channel-NcnPEVL4.js';
+
+const { promise, resolve } = withResolvers();
+
+const channel = 'broadcast';
+
+var broadcast = handler(
+  promise,
+  ({ data: [sab, main, channel] }) => resolve([sab, main, new BroadcastChannel(channel)]),
+);
+
+export { channel, broadcast as default };

package/dist/proxy/main/channel-NcnPEVL4.js

@@ -0,0 +1,110 @@
+let i = 0;
+
+const FALSE = i++;
+const TRUE = i++;
+
+const UNDEFINED = i++;
+const NULL = i++;
+
+const NUMBER = i++;
+const UI8 = i++;
+const NAN = i++;
+const INFINITY = i++;
+const N_INFINITY = i++;
+const ZERO = i++;
+const N_ZERO = i++;
+
+const BIGINT = i++;
+const BIGUINT = i++;
+
+const STRING = i++;
+
+const SYMBOL = i++;
+
+const ARRAY = i++;
+const BUFFER = i++;
+const DATE = i++;
+const ERROR = i++;
+const MAP = i++;
+const OBJECT = i++;
+const REGEXP = i++;
+const SET = i++;
+const VIEW = i++;
+
+const IMAGE_DATA = i++;
+const BLOB = i++;
+const FILE = i++;
+
+const RECURSION = i++;
+
+class Never {}
+
+const ImageData = globalThis.ImageData || /** @type {typeof ImageData} */(Never);
+
+const decoder = new TextDecoder;
+
+const encoder = new TextEncoder;
+
+/** @type {Map<symbol, string>} */
+const symbols = new Map(
+  Reflect.ownKeys(Symbol).map(
+    key => [Symbol[key], `@${String(key)}`]
+  )
+);
+
+/**
+ * @param {symbol} value
+ * @param {string} description
+ * @returns {string}
+ */
+const asSymbol = (value, description) => (
+  description === void 0 ? '?' :
+  (Symbol.keyFor(value) === void 0 ? `!${description}` : `#${description}`)
+);
+
+/**
+ * Extract the value from a pair of type and value.
+ * @param {string} name
+ * @returns {symbol}
+ */
+const fromSymbol = name => {
+  switch (name[0]) {
+    case '@': return Symbol[name.slice(1)];
+    case '#': return Symbol.for(name.slice(1));
+    case '!': return Symbol(name.slice(1));
+    default: return Symbol();
+  }
+};
+
+/**
+ * Create the name of a symbol.
+ * @param {symbol} value
+ * @returns {string}
+ */
+const toSymbol = value => symbols.get(value) || asSymbol(value, value.description);
+
+const defineProperty = Object.defineProperty;
+
+const isArray = Array.isArray;
+
+const isView = ArrayBuffer.isView;
+
+const MAX_ARGS = 0x7FFF;
+
+/**
+ * @param {number[]} output
+ * @param {Uint8Array} value 
+ */
+const push = (output, value) => {
+  for (let $ = output.push, i = 0, length = value.length; i < length; i += MAX_ARGS)
+    $.apply(output, value.subarray(i, i + MAX_ARGS));
+};
+
+const buffer = new ArrayBuffer(8);
+const dv = new DataView(buffer);
+const u8a8 = new Uint8Array(buffer);
+
+// shorter: 'fc260aad-4404-43b8-ae9d-2c06554bb294'.split('-').map(s => parseInt(s, 16)).reduce((p, c) => p + c).toString(16)
+var SHARED_CHANNEL = 'fc260aad-4404-43b8-ae9d-2c06554bb294';
+
+export { ARRAY as A, BLOB as B, DATE as D, ERROR as E, FILE as F, INFINITY as I, MAP as M, NULL as N, OBJECT as O, RECURSION as R, SYMBOL as S, TRUE as T, UI8 as U, VIEW as V, ZERO as Z, BIGUINT as a, BIGINT as b, N_ZERO as c, dv as d, N_INFINITY as e, fromSymbol as f, NAN as g, FALSE as h, REGEXP as i, IMAGE_DATA as j, ImageData as k, defineProperty as l, SET as m, STRING as n, decoder as o, BUFFER as p, NUMBER as q, SHARED_CHANNEL as r, UNDEFINED as s, toSymbol as t, u8a8 as u, encoder as v, isView as w, isArray as x, push as y };

package/dist/proxy/main/i32-UV5fM9Tw.js

@@ -0,0 +1,12 @@
+// @ts-check
+
+/**
+ * @param {number} [start]
+ * @returns {() => number}
+ */
+var i32 = start => {
+  const i32 = new Int32Array(1);
+  return () => i32[0]++;
+};
+
+export { i32 as i };

package/dist/proxy/main/message-j-4BYSZ4.js

@@ -0,0 +1,24 @@
+import { b as bootstrap, S as Sender, a as SAB, h as handler, u as url, p as post } from './shared-DdPca9Ke.js';
+import './shared-CV7CPYuP.js';
+import './i32-UV5fM9Tw.js';
+import './channel-NcnPEVL4.js';
+
+const CHANNEL = 'message';
+
+var message = bootstrap(class Worker extends Sender {
+  constructor(scriptURL, options, resolve) {
+    const { port1, port2 } = new MessageChannel;
+    const sab = SAB(options);
+    port1.addEventListener(CHANNEL, handler(sab, options, true));
+    port1.start();
+    super(...url(scriptURL, CHANNEL, options));
+    super.addEventListener(CHANNEL, () => resolve(this), { once: true });
+    super.postMessage(post(sab, options), [port2]);
+  }
+
+  get channel() {
+    return CHANNEL;
+  }
+});
+
+export { message as default };

package/dist/proxy/main/message-uirwoNUQ.js

@@ -0,0 +1,15 @@
+import { w as withResolvers } from './shared-CV7CPYuP.js';
+import { h as handler } from './shared-C3U1MNPd.js';
+import './sender-Dkjjbv2Y.js';
+import './channel-NcnPEVL4.js';
+
+const { promise, resolve } = withResolvers();
+
+const channel = 'message';
+
+var message = handler(
+  promise,
+  ({ data: [sab, main], ports: [channel] }) => resolve([sab, main, channel])
+);
+
+export { channel, message as default };

package/dist/proxy/main/proxy.js

@@ -1 +1,106 @@
-import{w as a,a as t,c as e}from"./shared-z_jGYqUa.js";import{n as r}from"./shared-array-buffer-cwdMr2mc.js";let s,n;if("importScripts"in globalThis){let t;const{promise:e,resolve:r}=a(),i=new URL(location).searchParams.get("reflected");s=i,t="message"===i?import("./message-DxRlOVN7.js"):"broadcast"===i?import("./broadcast-BX9FmxMK.js"):"xhr"===i?import("./xhr-BaBkekSn.js"):import("./async-CyZdYOvJ.js"),n=async a=>{const{data:r,ports:s}=await e,{default:n}=await t,i=new Event("message");return i.data=r,i.ports=s,dispatchEvent(i),n(a)},addEventListener("message",r,{once:!0})}else r?"InstallTrigger"in globalThis?(s="broadcast",n=(await import("./broadcast-DXhTouQy.js")).default):(s="message",n=(await import("./message-CbPHeJAY.js")).default):navigator.serviceWorker?(s="xhr",n=(await import("./xhr-Fg-l74MV.js")).default):(s="async",n=(await import("./async-Bc0QcTaC.js").then(function(a){return a.a})).default);var i=n;var o=async(a,r)=>{let s=0,n="";const o=r.debug??!1,c=e(null),l=await i(a,{...r,onsync:o?async([a,t])=>{n=a;try{return await(c[a]?.(...t))}finally{n=""}}:([a,t])=>c[a]?.(...t)});return t(l,{proxy:new Proxy(c,{get:o?(a,t)=>a[t]??(a[t]=async(...a)=>{n&&(s=setTimeout(console.warn,3e3,((a,t)=>`💀🔒 - main.${String(a)}() is invoking worker.${String(t)}()`)(n,t)));try{return await l.send([t,a])}finally{n="",clearTimeout(s)}}):(a,t)=>a[t]??(a[t]=(...a)=>l.send([t,a])),set:(a,t,e)=>{const r="then"!==t;return r&&(a[t]=e),r}})})};export{s as channel,o as default};
+import { w as withResolvers, a as assign, c as create } from './shared-CV7CPYuP.js';
+import { n as native } from './shared-array-buffer-BQgQXQvC.js';
+
+/** @typedef {import('./main/shared.js').Options} MainOptions */
+/** @typedef {import('./worker/shared.js').Options} WorkerOptions */
+
+/** @type {string} */
+let channel;
+
+/** @type {Function} */
+let module$1;
+
+if ('importScripts' in globalThis) {
+  let get;
+  const { promise, resolve } = withResolvers();
+  // @ts-ignore
+  const reflected = new URL(location).searchParams.get('reflected');
+  channel = reflected;
+  if (reflected === 'message') get = import(/* webpackIgnore: true */'./message-uirwoNUQ.js');
+  else if (reflected === 'broadcast') get = import(/* webpackIgnore: true */'./broadcast-LNW6nFVD.js');
+  else if (reflected === 'xhr') get = import(/* webpackIgnore: true */'./xhr-WnkM0dVo.js');
+  else get = import(/* webpackIgnore: true */'./async-8J3q5T6q.js');
+  module$1 = async options => {
+    const { data, ports } = await promise;
+    const { default: reflect } = await get;
+    const event = new Event('message');
+    // @ts-ignore
+    event.data = data;
+    // @ts-ignore
+    event.ports = ports;
+    dispatchEvent(event);
+    return reflect(options);
+  };
+  addEventListener('message', resolve, { once: true });
+}
+else if (native) {
+  if ('InstallTrigger' in globalThis) {
+    channel = 'broadcast';
+    module$1 = (await import(/* webpackIgnore: true */'./broadcast-CR8vlkKk.js')).default;
+  }
+  else {
+    channel = 'message';
+    module$1 = (await import(/* webpackIgnore: true */'./message-j-4BYSZ4.js')).default;
+  }
+}
+else if (navigator.serviceWorker) {
+  channel = 'xhr';
+  module$1 = (await import(/* webpackIgnore: true */'./xhr-BUjEbkCh.js')).default;
+}
+else {
+  channel = 'async';
+  module$1 = (await import(/* webpackIgnore: true */'./async-Di4MuQWe.js').then(function (n) { return n.a; })).default;
+}
+
+var reflected = module$1;
+
+/**
+ * @param {string | symbol} syncing
+ * @param {string | symbol} name
+ * @returns
+ */
+const deadlock = (syncing, name) => `💀🔒 - main.${String(syncing)}() is invoking worker.${String(name)}()`;
+
+var proxy = async (url, options) => {
+  let t = 0, syncing = '';
+  const debug = options.debug ?? false;
+  const target = create(null);
+  const worker = await reflected(url, {
+    ...options,
+    onsync: (
+      debug ?
+        (async ([name, args]) => {
+          syncing = name;
+          try { return await target[name]?.(...args) }
+          finally { syncing = ''; }
+        }) :
+        (([name, args]) => target[name]?.(...args))
+    )
+  });
+  return assign(worker, {
+    proxy: new Proxy(target, {
+      get: debug ?
+        (target, name) => (
+          target[name] ??
+          (target[name] = async (...args) => {
+            if (syncing) t = setTimeout(console.warn, 3e3, deadlock(syncing, name));
+            try { return await worker.send([name, args]) }
+            finally {
+              syncing = '';
+              clearTimeout(t);
+            }
+          })
+        ) :
+        ((target, name) => (
+          target[name] ?? (target[name] = (...args) => worker.send([name, args]))
+        )),
+      set: (target, name, value) => {
+        const ok = name !== 'then';
+        if (ok) target[name] = value;
+        return ok;
+      },
+    }),
+  });
+};
+
+export { channel, proxy as default };

package/dist/proxy/main/sender-Dkjjbv2Y.js

@@ -0,0 +1,194 @@
+import { F as FILE, B as BLOB, R as RECURSION, S as SYMBOL, f as fromSymbol, a as BIGUINT, d as dv, b as BIGINT, N as NULL, c as N_ZERO, Z as ZERO, e as N_INFINITY, I as INFINITY, g as NAN, T as TRUE, h as FALSE, i as REGEXP, j as IMAGE_DATA, k as ImageData, E as ERROR, l as defineProperty, m as SET, M as MAP, D as DATE, n as STRING, o as decoder$1, p as BUFFER, V as VIEW, A as ARRAY, O as OBJECT, U as UI8, q as NUMBER, u as u8a8, r as SHARED_CHANNEL } from './channel-NcnPEVL4.js';
+import { i as identity } from './shared-CV7CPYuP.js';
+
+//@ts-check
+
+
+/** @typedef {Map<number, any>} Cache */
+
+/**
+ * @param {Cache} cache
+ * @param {number} index
+ * @param {any} value
+ * @returns {any}
+ */
+const $ = (cache, index, value) => {
+  cache.set(index, value);
+  return value;
+};
+
+/**
+ * @param {Uint8Array} input
+ */
+const number = input => {
+  u8a8[0] = input[i++];
+  u8a8[1] = input[i++];
+  u8a8[2] = input[i++];
+  u8a8[3] = input[i++];
+  u8a8[4] = input[i++];
+  u8a8[5] = input[i++];
+  u8a8[6] = input[i++];
+  u8a8[7] = input[i++];
+};
+
+/**
+ * @param {Uint8Array} input
+ * @returns {number}
+ */
+const size = input => {
+  u8a8[0] = input[i++];
+  u8a8[1] = input[i++];
+  u8a8[2] = input[i++];
+  u8a8[3] = input[i++];
+  return dv.getUint32(0, true);
+};
+
+/**
+ * @param {Uint8Array} input
+ * @param {Cache} cache
+ * @returns {any}
+ */
+const deflate = (input, cache) => {
+  switch (input[i++]) {
+    case NUMBER: {
+      number(input);
+      return dv.getFloat64(0, true);
+    }
+    case UI8: return input[i++];
+    case OBJECT: {
+      const object = $(cache, i - 1, {});
+      for (let j = 0, length = size(input); j < length; j++)
+        object[deflate(input, cache)] = deflate(input, cache);
+      return object;
+    }
+    case ARRAY: {
+      const array = $(cache, i - 1, []);
+      for (let j = 0, length = size(input); j < length; j++)
+        array.push(deflate(input, cache));
+      return array;
+    }
+    case VIEW: {
+      const index = i - 1;
+      const name = deflate(input, cache);
+      return $(cache, index, new globalThis[name](deflate(input, cache)));
+    }
+    case BUFFER: {
+      const index = i - 1;
+      const length = size(input);
+      return $(cache, index, input.slice(i, i += length).buffer);
+    }
+    case STRING: {
+      const index = i - 1;
+      const length = size(input);
+      // this could be a subarray but it's not supported on the Web and
+      // it wouldn't work with arrays instead of typed arrays.
+      return $(cache, index, decoder$1.decode(input.slice(i, i += length)));
+    }
+    case DATE: {
+      return $(cache, i - 1, new Date(deflate(input, cache)));
+    }
+    case MAP: {
+      const map = $(cache, i - 1, new Map);
+      for (let j = 0, length = size(input); j < length; j++)
+        map.set(deflate(input, cache), deflate(input, cache));
+      return map;
+    }
+    case SET: {
+      const set = $(cache, i - 1, new Set);
+      for (let j = 0, length = size(input); j < length; j++)
+        set.add(deflate(input, cache));
+      return set;
+    }
+    case ERROR: {
+      const index = i - 1;
+      const name = deflate(input, cache);
+      const message = deflate(input, cache);
+      const stack = deflate(input, cache);
+      const Class = globalThis[name] || Error;
+      const error = new Class(message);
+      return $(cache, index, defineProperty(error, 'stack', { value: stack }));
+    }
+    /* c8 ignore start */
+    case IMAGE_DATA: {
+      const index = i - 1;
+      const data = deflate(input, cache);
+      const width = deflate(input, cache);
+      const height = deflate(input, cache);
+      const colorSpace = deflate(input, cache);
+      const pixelFormat = deflate(input, cache);
+      const settings = { colorSpace, pixelFormat };
+      return $(cache, index, new ImageData(data, width, height, settings));
+    }
+    /* c8 ignore stop */
+    case REGEXP: {
+      const index = i - 1;
+      const source = deflate(input, cache);
+      const flags = deflate(input, cache);
+      return $(cache, index, new RegExp(source, flags));
+    }
+    case FALSE: return false;
+    case TRUE: return true;
+    case NAN: return NaN;
+    case INFINITY: return Infinity;
+    case N_INFINITY: return -Infinity;
+    case ZERO: return 0;
+    case N_ZERO: return -0;
+    case NULL: return null;
+    case BIGINT: return (number(input), dv.getBigInt64(0, true));
+    case BIGUINT: return (number(input), dv.getBigUint64(0, true));
+    case SYMBOL: return fromSymbol(deflate(input, cache));
+    case RECURSION: return cache.get(size(input));
+    case BLOB: {
+      const index = i - 1;
+      const type = deflate(input, cache);
+      const size = deflate(input, cache);
+      return $(cache, index, new Blob([input.slice(i, i += size)], { type }));
+    }
+    case FILE: {
+      const index = i - 1;
+      const name = deflate(input, cache);
+      const lastModified = deflate(input, cache);
+      const blob = deflate(input, cache);
+      return $(cache, index, new File([blob], name, { type: blob.type, lastModified }));
+    }
+    // this covers functions too
+    default: return undefined;
+  }
+};
+
+let i = 0;
+
+/**
+ * @param {Uint8Array} value
+ * @returns {any}
+ */
+const decode = value => {
+  i = 0;
+  return deflate(value, new Map);
+};
+
+/**
+ * @param {{ byteOffset?: number }} [options]
+ * @returns {(length: number, buffer: ArrayBufferLike) => any}
+ */
+const decoder = ({ byteOffset = 0 } = {}) => (length, buffer) => decode(
+  new Uint8Array(buffer, byteOffset, length)
+);
+
+const { isArray } = Array;
+
+var sender = options => {
+  const onsend = options.onsend ?? identity;
+  addEventListener('message', async event => {
+    const { data } = event;
+    if (isArray(data) && data[0] === SHARED_CHANNEL) {
+      event.stopImmediatePropagation();
+      event.preventDefault();
+      const [id, payload] = data[1];
+      postMessage([SHARED_CHANNEL, [id, await onsend(payload)]]);
+    }
+  });
+  return options;
+};
+
+export { decoder as d, sender as s };

package/dist/proxy/main/shared-C3U1MNPd.js

@@ -0,0 +1,53 @@
+import { s as sender, d as decoder } from './sender-Dkjjbv2Y.js';
+import { b as byteOffset, i as identity } from './shared-CV7CPYuP.js';
+
+const { load, store, wait } = Atomics;
+
+/**
+ * @typedef {Object} Options
+ * @property {(payload: Int32Array) => unknown} [onsync] transforms the resulting `Int32Array` from *main* thread into a value usable within the worker.
+ * @property {(payload: unknown) => unknown |Promise<unknown>} onsend invoked to define what to return to the *main* thread when it calls `worker.send(payload)`.
+ * @property {import('reflected-ffi/decoder').decoder} [decoder] defines the decoder function to use to decode the result from the SharedArrayBuffer.
+ */
+
+/**
+ * @param {MessageChannel | BroadcastChannel} channel
+ * @param {Int32Array} i32a
+ * @param {Options} options
+ * @returns {(payload: unknown, ...rest: unknown[]) => unknown}
+ */
+const handle = (channel, i32a, options) => {
+  const decode = (options.decoder ?? decoder)({ byteOffset });
+  const onsync = options.onsync ?? identity;
+  const { buffer } = i32a;
+  return (payload, ...rest) => {
+    // @ts-ignore
+    channel.postMessage(payload, ...rest);
+    wait(i32a, 0, 0);
+    store(i32a, 0, 0);
+    const length = load(i32a, 1);
+    return onsync(length ? decode(length, buffer) : void 0);
+  };
+};
+
+/**
+ * 
+ * @param {Promise<[SharedArrayBuffer, Options, MessageChannel | BroadcastChannel]>} promise
+ * @param {(event:MessageEvent) => void} listener
+ * @returns
+ */
+const handler = (promise, listener) => {
+  addEventListener('message', listener, { once: true });
+  /**
+   * @param {Options} options
+   * @returns
+   */
+  return options => promise.then(
+    ([sab, main, channel]) => {
+      postMessage(1);
+      return handle(channel, new Int32Array(sab), sender({ ...main, ...options }));
+    }
+  );
+};
+
+export { handler as h };

package/dist/proxy/main/shared-CV7CPYuP.js

@@ -0,0 +1,43 @@
+//@ts-check
+
+/**
+ * @template T
+ * @typedef {{promise: Promise<T>, resolve: (value: T) => void, reject: (reason?: any) => void}} Resolvers
+ */
+
+// fallback for Android WebView
+//@ts-ignore
+const withResolvers = Promise.withResolvers || function withResolvers() {
+  var a, b, c = new this((resolve, reject) => {
+    a = resolve;
+    b = reject;
+  });
+  return {resolve: a, reject: b, promise: c};
+};
+
+/**
+ * @template T
+ * @type {() => Resolvers<T>}
+ */
+var withResolvers$1 = withResolvers.bind(Promise);
+
+const assign = Object.assign;
+
+const create = Object.create;
+
+const byteOffset = Int32Array.BYTES_PER_ELEMENT * 2;
+
+let hasRandomUUID = true;
+try {
+  crypto.randomUUID();
+} catch (_) {
+  hasRandomUUID = false;
+}
+
+const identity = value => value;
+
+const randomUUID = hasRandomUUID ?
+  (() => crypto.randomUUID() ):
+  (() => (Date.now() + Math.random()).toString(36));
+
+export { assign as a, byteOffset as b, create as c, identity as i, randomUUID as r, withResolvers$1 as w };