reflected 0.2.5 → 0.2.6

package/dist/broadcast.js

@@ -1 +1,850 @@
-const e=Promise.withResolvers||function(){var e,t,s=new this((s,n)=>{e=s,t=n});return{resolve:e,reject:t,promise:s}};var t=e.bind(Promise),s="fc260aad-4404-43b8-ae9d-2c06554bb294";const n=2*Int32Array.BYTES_PER_ELEMENT;let r=!0;try{crypto.randomUUID()}catch(e){r=!1}const a=e=>e,o=r?()=>crypto.randomUUID():()=>(Date.now()+Math.random()).toString(36),{isArray:c}=Array;class i extends Worker{#e;#t;constructor(e,t){const n=t.onsend??a;super(e,t),this.#e=(()=>{const e=new Int32Array(1);return()=>e[0]++})(),this.#t=new Map,super.addEventListener("message",async e=>{const{data:t}=e;if(c(t)&&2===t.length&&t[0]===s){e.stopImmediatePropagation(),e.preventDefault();const[s,r]=t[1],a=this.#t.get(s);this.#t.delete(s),a(await n(r))}})}send(e,...n){const r=this.#e(),{promise:a,resolve:o}=t();return this.#t.set(r,o),super.postMessage([s,[r,e]],...n),a}}let u=0;const l=u++,h=u++,f=u++,p=u++,y=u++,g=u++,d=u++,b=u++,w=u++,m=u++,v=u++,A=u++,k=u++,S=u++,B=u++,U=u++,E=u++,M=u++,x=u++,I=u++,L=u++,O=u++,T=u++,D=u++,P=u++,F=u++,N=u++,R=u++;const j=globalThis.ImageData||class{};class q{static push(e,t){e.sync(!1),e._(t,t.length)}constructor(e,t){const s=[];this.l=0,this.o=s,this.v=new Uint8Array(e,t),this.push=s.push.bind(s)}get length(){return this.l+this.o.length}sync(e){const t=this.o,s=t.length;s&&this._(e?t:t.splice(0),s)}_(e,t){const{buffer:s,byteOffset:n}=this.v,r=this.l;this.l+=t,t+=n+r,s.byteLength<t&&s.grow(t),this.v.set(e,r)}}const _=new Map(Reflect.ownKeys(Symbol).map(e=>[Symbol[e],`@${String(e)}`])),z=e=>_.get(e)||((e,t)=>void 0===t?"?":void 0===Symbol.keyFor(e)?`!${t}`:`#${t}`)(e,e.description),$=Object.defineProperty,C=Array.isArray,J=ArrayBuffer.isView,K=new TextDecoder,V=new TextEncoder,W=new ArrayBuffer(8),Y=new DataView(W),G=new Uint8Array(W),{getPrototypeOf:H}=Object,{construct:Q}=Reflect,{toStringTag:X}=Symbol,Z=(e,t=e[X])=>t in globalThis?t:Z(Q(H(e.constructor),[0])),{isNaN:ee,isFinite:te,isInteger:se}=Number,{ownKeys:ne}=Reflect,{is:re}=Object,ae=(e,t,s)=>{const n=s.get(e),r=!n;return r?(Y.setUint32(0,t.length,!0),s.set(e,[G[0],G[1],G[2],G[3]])):t.push(R,n[0],n[1],n[2],n[3]),r},oe=(e,t,s)=>{Y.setUint32(0,s,!0),e.push(t,G[0],G[1],G[2],G[3])},ce=(e,t,s)=>{switch(typeof e){case"number":e&&te(e)?se(e)&&e<256&&-1<e?t.push(g,e):(Y.setFloat64(0,e,!0),t.push(y,G[0],G[1],G[2],G[3],G[4],G[5],G[6],G[7])):ee(e)?t.push(d):e?t.push(e<0?w:b):t.push(re(e,0)?m:v);break;case"object":switch(!0){case null===e:t.push(p);break;case!ae(e,t,s):break;case C(e):{const n=e.length;oe(t,U,n);for(let r=0;r<n;r++)ce(e[r],t,s);break}case J(e):if(t.push(D),ce(Z(e),t,s),e=e.buffer,!ae(e,t,s))break;case e instanceof ArrayBuffer:{const s=new Uint8Array(e);oe(t,E,s.length),ue(t,s);break}case e instanceof Date:t.push(M),ce(e.getTime(),t,s);break;case e instanceof Map:oe(t,I,e.size);for(const[n,r]of e)ce(n,t,s),ce(r,t,s);break;case e instanceof Set:oe(t,T,e.size);for(const n of e)ce(n,t,s);break;case e instanceof Error:t.push(x),ce(e.name,t,s),ce(e.message,t,s),ce(e.stack,t,s);break;case e instanceof j:t.push(P),ce(e.data,t,s),ce(e.width,t,s),ce(e.height,t,s),ce(e.colorSpace,t,s),ce(e.pixelFormat,t,s);break;case e instanceof RegExp:t.push(O),ce(e.source,t,s),ce(e.flags,t,s);break;case e instanceof File:t.push(N),ce(e.name,t,s),ce(e.lastModified,t,s);case e instanceof Blob:{const n=e.size;t.push(F),ce(e.type,t,s),ce(n,t,s);const r=t.length;ue(t,new Uint8Array(n)),ie.push(e.arrayBuffer().then(e=>[r,e]));break}default:if("toJSON"in e){const n=e.toJSON();ce(n===e?null:n,t,s)}else{const n=ne(e),r=n.length;oe(t,L,r);for(let a=0;a<r;a++){const r=n[a];ce(r,t,s),ce(e[r],t,s)}}}break;case"string":if(ae(e,t,s)){const s=V.encode(e);oe(t,S,s.length),ue(t,s)}break;case"boolean":t.push(e?h:l);break;case"symbol":t.push(B),ce(z(e),t,s);break;case"bigint":{let s=A;9223372036854775807n<e?(Y.setBigUint64(0,e,!0),s=k):Y.setBigInt64(0,e,!0),t.push(s,G[0],G[1],G[2],G[3],G[4],G[5],G[6],G[7]);break}default:t.push(f)}},ie=[];let ue=(e,t)=>{for(let s=e.push,n=0,r=t.length;n<r;n+=32767)s.apply(e,t.subarray(n,n+32767))};const le=({byteOffset:e=0,Array:t=q}={})=>(s,n)=>{const r=new t(n,e);ue=t.push,ce(s,r,new Map);const a=r.length;return r.sync(!0),ie.length?Promise.all(ie.splice(0)).then(t=>{const s=new Uint8Array(n,e);for(const[e,n]of t)s.set(new Uint8Array(n),e);return a}):a},{notify:he,store:fe}=Atomics,pe=(e,t,s)=>{const r=new Int32Array(e),o=(t.encoder??le)({byteOffset:n}),c=t.onsync??a,i=e=>{fe(r,1,e),fe(r,0,1),he(r,0)};return async({data:t})=>(t=>{const s=o(t,e);return"number"==typeof s?i(s):s.then(i)})(await c(t))},ye=e=>{switch(typeof e){case"symbol":case"function":return!1}return!0},ge="broadcast";var de=(e=>(s,n)=>{const{promise:r,resolve:a}=t();return new e(s,n,a),r})(class extends i{constructor(e,t,s){const r=o(),a=new BroadcastChannel(r),c=(({initByteLength:e=1024,maxByteLength:t=8192})=>new SharedArrayBuffer(n+e,{maxByteLength:n+t}))(t);a.addEventListener("message",pe(c,t)),super(...((e,t,s)=>{const n=new URL(e,location.href);return n.searchParams.set("reflected",t),[n,{...s,type:"module"}]})(e,ge,t)),super.addEventListener("message",()=>s(this),{once:!0}),super.postMessage(((e,t)=>{const s={};for(const e in t){const n=t[e];ye(e)&&ye(n)&&(s[e]=n)}return[e,s]})(c,t).concat(r))}get channel(){return ge}});const be=(e,t,s)=>(e.set(t,s),s),we=e=>{G[0]=e[Ae++],G[1]=e[Ae++],G[2]=e[Ae++],G[3]=e[Ae++],G[4]=e[Ae++],G[5]=e[Ae++],G[6]=e[Ae++],G[7]=e[Ae++]},me=e=>(G[0]=e[Ae++],G[1]=e[Ae++],G[2]=e[Ae++],G[3]=e[Ae++],Y.getUint32(0,!0)),ve=(e,t)=>{switch(e[Ae++]){case y:return we(e),Y.getFloat64(0,!0);case g:return e[Ae++];case L:{const s=be(t,Ae-1,{});for(let n=0,r=me(e);n<r;n++)s[ve(e,t)]=ve(e,t);return s}case U:{const s=be(t,Ae-1,[]);for(let n=0,r=me(e);n<r;n++)s.push(ve(e,t));return s}case D:{const s=Ae-1,n=ve(e,t);return be(t,s,new globalThis[n](ve(e,t)))}case E:{const s=Ae-1,n=me(e);return be(t,s,e.slice(Ae,Ae+=n).buffer)}case S:{const s=Ae-1,n=me(e);return be(t,s,K.decode(e.slice(Ae,Ae+=n)))}case M:return be(t,Ae-1,new Date(ve(e,t)));case I:{const s=be(t,Ae-1,new Map);for(let n=0,r=me(e);n<r;n++)s.set(ve(e,t),ve(e,t));return s}case T:{const s=be(t,Ae-1,new Set);for(let n=0,r=me(e);n<r;n++)s.add(ve(e,t));return s}case x:{const s=Ae-1,n=ve(e,t),r=ve(e,t),a=ve(e,t),o=new(globalThis[n]||Error)(r);return be(t,s,$(o,"stack",{value:a}))}case P:{const s=Ae-1,n=ve(e,t),r=ve(e,t),a=ve(e,t),o=ve(e,t),c=ve(e,t);return be(t,s,new j(n,r,a,{colorSpace:o,pixelFormat:c}))}case O:{const s=Ae-1,n=ve(e,t),r=ve(e,t);return be(t,s,new RegExp(n,r))}case l:return!1;case h:return!0;case d:return NaN;case b:return 1/0;case w:return-1/0;case m:return 0;case v:return-0;case p:return null;case A:return we(e),Y.getBigInt64(0,!0);case k:return we(e),Y.getBigUint64(0,!0);case B:return(e=>{switch(e[0]){case"@":return Symbol[e.slice(1)];case"#":return Symbol.for(e.slice(1));case"!":return Symbol(e.slice(1));default:return Symbol()}})(ve(e,t));case R:return t.get(me(e));case F:{const s=Ae-1,n=ve(e,t),r=ve(e,t);return be(t,s,new Blob([e.slice(Ae,Ae+=r)],{type:n}))}case N:{const s=Ae-1,n=ve(e,t),r=ve(e,t),a=ve(e,t);return be(t,s,new File([a],n,{type:a.type,lastModified:r}))}default:return}};let Ae=0;const ke=({byteOffset:e=0}={})=>(t,s)=>{return n=new Uint8Array(s,e,t),Ae=0,ve(n,new Map);var n},{isArray:Se}=Array;const{load:Be,store:Ue,wait:Ee}=Atomics,{promise:Me,resolve:xe}=t(),Ie="broadcast";var Le=((e,t)=>(addEventListener("message",t,{once:!0}),t=>e.then(([e,r,o])=>(postMessage(1),((e,t,s)=>{const r=(s.decoder??ke)({byteOffset:n}),o=s.onsync??a,{buffer:c}=t;return(s,...n)=>{e.postMessage(s,...n),Ee(t,0,0),Ue(t,0,0);const a=Be(t,1);return o(a?r(a,c):void 0)}})(o,new Int32Array(e),(e=>{const t=e.onsend??a;return addEventListener("message",async e=>{const{data:n}=e;if(Se(n)&&n[0]===s){e.stopImmediatePropagation(),e.preventDefault();const[r,a]=n[1];postMessage([s,[r,await t(a)]])}}),e})({...r,...t}))))))(Me,({data:[e,t,s]})=>xe([e,t,new BroadcastChannel(s)])),Oe="importScripts"in globalThis?Le:de;export{Ie as channel,Oe as default};
+//@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);
+
+// @ts-check
+
+/**
+ * @param {number} [start]
+ * @returns {() => number}
+ */
+var i32 = start => {
+  const i32 = new Int32Array(1);
+  return () => i32[0]++;
+};
+
+// 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';
+
+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));
+
+const { isArray: isArray$2 } = Array;
+
+class Sender extends Worker {
+  #next;
+  #requests;
+  constructor(scriptURL, options) {
+    const onsend = options.onsend ?? identity;
+    super(scriptURL, options);
+    this.#next = i32();
+    this.#requests = new Map;
+    super.addEventListener('message', async event => {
+      const { data } = event;
+      if (isArray$2(data) && data.length === 2 && data[0] === SHARED_CHANNEL) {
+        event.stopImmediatePropagation();
+        event.preventDefault();
+        const [id, payload] = data[1];
+        const resolve = this.#requests.get(id);
+        this.#requests.delete(id);
+        resolve(await onsend(payload));
+      }
+    });
+  }
+
+  send(payload, ...rest) {
+    const id = this.#next();
+    const { promise, resolve } = withResolvers$1();
+    this.#requests.set(id, resolve);
+    super.postMessage([SHARED_CHANNEL, [id, payload]], ...rest);
+    return promise;
+  }
+}
+
+let i$1 = 0;
+
+const FALSE = i$1++;
+const TRUE = i$1++;
+
+const UNDEFINED = i$1++;
+const NULL = i$1++;
+
+const NUMBER = i$1++;
+const UI8 = i$1++;
+const NAN = i$1++;
+const INFINITY = i$1++;
+const N_INFINITY = i$1++;
+const ZERO = i$1++;
+const N_ZERO = i$1++;
+
+const BIGINT = i$1++;
+const BIGUINT = i$1++;
+
+const STRING = i$1++;
+
+const SYMBOL = i$1++;
+
+const ARRAY = i$1++;
+const BUFFER = i$1++;
+const DATE = i$1++;
+const ERROR = i$1++;
+const MAP = i$1++;
+const OBJECT = i$1++;
+const REGEXP = i$1++;
+const SET = i$1++;
+const VIEW = i$1++;
+
+const IMAGE_DATA = i$1++;
+const BLOB = i$1++;
+const FILE = i$1++;
+
+const RECURSION = i$1++;
+
+class Never {}
+
+const ImageData = globalThis.ImageData || /** @type {typeof ImageData} */(Never);
+
+// This is an Array facade for the encoder.
+
+class Stack {
+  /**
+   * @param {Stack} self
+   * @param {Uint8Array} value
+   */
+  static push(self, value) {
+    self.sync(false);
+    self._(value, value.length);
+  }
+
+  /**
+   * @param {ArrayBufferLike} buffer
+   * @param {number} offset
+   */
+  constructor(buffer, offset) {
+    /** @type {number[]} */
+    const output = [];
+
+    /** @private length */
+    this.l = 0;
+
+    /** @private output */
+    this.o = output;
+
+    /** @private view */
+    this.v = new Uint8Array(buffer, offset);
+
+    /** @type {typeof Array.prototype.push} */
+    this.push = output.push.bind(output);
+  }
+
+  /**
+   * @type {number}
+   */
+  get length() {
+    return this.l + this.o.length;
+  }
+
+  /**
+   * Sync all entries in the output to the buffer.
+   * @param {boolean} last `true` if it's the last sync.
+   */
+  sync(last) {
+    const output = this.o;
+    const length = output.length;
+    if (length) this._(last ? output : output.splice(0), length);
+  }
+
+  /**
+   * Set a value to the buffer
+   * @private
+   * @param {Uint8Array|number[]} value
+   * @param {number} byteLength
+   */
+  _(value, byteLength) {
+    const { buffer, byteOffset } = this.v;
+    const offset = this.l;
+    this.l += byteLength;
+    byteLength += byteOffset + offset;
+    if (buffer.byteLength < byteLength)
+      /** @type {SharedArrayBuffer} */(buffer).grow(byteLength);
+    this.v.set(value, offset);
+  }
+}
+
+/** @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$1 = 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 decoder$1 = new TextDecoder;
+
+const encoder$1 = new TextEncoder;
+
+const buffer = new ArrayBuffer(8);
+const dv = new DataView(buffer);
+const u8a8 = new Uint8Array(buffer);
+
+const { getPrototypeOf } = Object;
+const { construct } = Reflect;
+const { toStringTag } = Symbol;
+
+const toTag = (ref, name = ref[toStringTag]) =>
+  name in globalThis ? name : toTag(construct(getPrototypeOf(ref.constructor),[0]));
+
+//@ts-check
+
+
+/** @typedef {Map<number, number[]>} Cache */
+
+const { isNaN, isFinite, isInteger } = Number;
+const { ownKeys } = Reflect;
+const { is } = Object;
+
+/**
+ * @param {any} input
+ * @param {number[]|Stack} output
+ * @param {Cache} cache
+ * @returns {boolean}
+ */
+const process = (input, output, cache) => {
+  const value = cache.get(input);
+  const unknown = !value;
+  if (unknown) {
+    dv.setUint32(0, output.length, true);
+    cache.set(input, [u8a8[0], u8a8[1], u8a8[2], u8a8[3]]);
+  }
+  else
+    output.push(RECURSION, value[0], value[1], value[2], value[3]);
+  return unknown;
+};
+
+/**
+ * @param {number[]|Stack} output
+ * @param {number} type
+ * @param {number} length
+ */
+const set = (output, type, length) => {
+  dv.setUint32(0, length, true);
+  output.push(type, u8a8[0], u8a8[1], u8a8[2], u8a8[3]);
+};
+
+/**
+ * @param {any} input
+ * @param {number[]|Stack} output
+ * @param {Cache} cache
+ */
+const inflate = (input, output, cache) => {
+  switch (typeof input) {
+    case 'number': {
+      if (input && isFinite(input)) {
+        if (isInteger(input) && input < 256 && -1 < input)
+          output.push(UI8, input);
+        else {
+          dv.setFloat64(0, input, true);
+          output.push(NUMBER, u8a8[0], u8a8[1], u8a8[2], u8a8[3], u8a8[4], u8a8[5], u8a8[6], u8a8[7]);
+        }
+      }
+      else if (isNaN(input)) output.push(NAN);
+      else if (!input) output.push(is(input, 0) ? ZERO : N_ZERO);
+      else output.push(input < 0 ? N_INFINITY : INFINITY);
+      break;
+    }
+    case 'object': {
+      switch (true) {
+        case input === null:
+          output.push(NULL);
+          break;
+        case !process(input, output, cache): break;
+        case isArray$1(input): {
+          const length = input.length;
+          set(output, ARRAY, length);
+          for (let i = 0; i < length; i++)
+            inflate(input[i], output, cache);
+          break;
+        }
+        case isView(input): {
+          output.push(VIEW);
+          inflate(toTag(input), output, cache);
+          input = input.buffer;
+          if (!process(input, output, cache)) break;
+          // fallthrough
+        }
+        case input instanceof ArrayBuffer: {
+          const ui8a = new Uint8Array(input);
+          set(output, BUFFER, ui8a.length);
+          //@ts-ignore
+          pushView(output, ui8a);
+          break;
+        }
+        case input instanceof Date:
+          output.push(DATE);
+          inflate(input.getTime(), output, cache);
+          break;
+        case input instanceof Map: {
+          set(output, MAP, input.size);
+          for (const [key, value] of input) {
+            inflate(key, output, cache);
+            inflate(value, output, cache);
+          }
+          break;
+        }
+        case input instanceof Set: {
+          set(output, SET, input.size);
+          for (const value of input)
+            inflate(value, output, cache);
+          break;
+        }
+        case input instanceof Error:
+          output.push(ERROR);
+          inflate(input.name, output, cache);
+          inflate(input.message, output, cache);
+          inflate(input.stack, output, cache);
+          break;
+        /* c8 ignore start */
+        case input instanceof ImageData:
+          output.push(IMAGE_DATA);
+          inflate(input.data, output, cache);
+          inflate(input.width, output, cache);
+          inflate(input.height, output, cache);
+          inflate(input.colorSpace, output, cache);
+          //@ts-ignore
+          inflate(input.pixelFormat, output, cache);
+          break;
+        /* c8 ignore stop */
+        case input instanceof RegExp:
+          output.push(REGEXP);
+          inflate(input.source, output, cache);
+          inflate(input.flags, output, cache);
+          break;
+        case input instanceof File: {
+          output.push(FILE);
+          inflate(input.name, output, cache);
+          inflate(input.lastModified, output, cache);
+          // fallthrough
+        }
+        case input instanceof Blob: {
+          const size = input.size;
+          output.push(BLOB);
+          inflate(input.type, output, cache);
+          inflate(size, output, cache);
+          const length = output.length;
+          //@ts-ignore
+          pushView(output, new Uint8Array(size));
+          blobs.push(input.arrayBuffer().then(buffer => [length, buffer]));
+          break;
+        }
+        default: {
+          if ('toJSON' in input) {
+            const json = input.toJSON();
+            inflate(json === input ? null : json, output, cache);
+          }
+          else {
+            const keys = ownKeys(input);
+            const length = keys.length;
+            set(output, OBJECT, length);
+            for (let i = 0; i < length; i++) {
+              const key = keys[i];
+              inflate(key, output, cache);
+              inflate(input[key], output, cache);
+            }
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case 'string': {
+      if (process(input, output, cache)) {
+        const encoded = encoder$1.encode(input);
+        set(output, STRING, encoded.length);
+        //@ts-ignore
+        pushView(output, encoded);
+      }
+      break;
+    }
+    case 'boolean': {
+      output.push(input ? TRUE : FALSE);
+      break;
+    }
+    case 'symbol': {
+      output.push(SYMBOL);
+      inflate(toSymbol(input), output, cache);
+      break;
+    }
+    case 'bigint': {
+      let type = BIGINT;
+      if (9223372036854775807n < input) {
+        dv.setBigUint64(0, input, true);
+        type = BIGUINT;
+      }
+      else dv.setBigInt64(0, input, true);
+      output.push(type, u8a8[0], u8a8[1], u8a8[2], u8a8[3], u8a8[4], u8a8[5], u8a8[6], u8a8[7]);
+      break;
+    }
+    // this covers functions too
+    default: {
+      output.push(UNDEFINED);
+      break;
+    }
+  }
+};
+
+const blobs = [];
+
+/** @type {typeof push|typeof Stack.push} */
+let pushView = push;
+
+/**
+ * @param {{ byteOffset?: number, Array?: typeof Stack }} [options]
+ * @returns {(value: any, buffer: ArrayBufferLike) => number | Promise<number>}
+ */
+const encoder = ({ byteOffset = 0, Array = Stack } = {}) => (value, buffer) => {
+  const output = new Array(buffer, byteOffset);
+  pushView = Array.push;
+  inflate(value, output, new Map);
+  const length = output.length;
+  output.sync(true);
+  return blobs.length ?
+    Promise.all(blobs.splice(0)).then(entries => {
+      const ui8a = new Uint8Array(buffer, byteOffset);
+      for (const [len, buff] of entries)
+        ui8a.set(new Uint8Array(buff), len);
+      return length;
+    }) :
+    length;
+};
+
+const { notify, store: store$1 } = Atomics;
+
+const SAB = ({
+  initByteLength = 1024,
+  maxByteLength = (1024 * 8)
+}) =>
+  new SharedArrayBuffer(
+    byteOffset + initByteLength,
+    { maxByteLength: byteOffset + maxByteLength }
+  );
+
+/**
+ * @typedef {Object} ServiceWorkerOptions see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register#options
+ * @property {string} [url] will use the `serviceWorker` value if that is a `string`, otherwise it refers to where the service worker file is located.
+ * @property {'classic' | 'module'} [type]
+ * @property {'all' | 'imports' | 'none'} [updateViaCache]
+ */
+
+/**
+ * @typedef {Object} Options
+ * @property {(payload: unknown) => Int32Array | Promise<Int32Array>} [onsync] invoked when the worker expect a response as `Int32Array` to populate the SharedArrayBuffer with.
+ * @property {(payload: unknown) => unknown | Promise<unknown>} [onsend] invoked when the worker replies to a `worker.send(data)` call.
+ * @property {string} [ws] the WebSocket URL to use for worker <-> server communication.
+ * @property {number} [initByteLength=1024] defines the initial byte length of the SharedArrayBuffer.
+ * @property {number} [maxByteLength=8192] defines the maximum byte length (growth) of the SharedArrayBuffer.
+ * @property {string | ServiceWorkerOptions} [serviceWorker] defines the service worker to use as fallback if SharedArrayBuffer is not supported. If not defined, the `async` fallback will be used so that no `sync` operations from the worker will be possible.
+ * @property {import('reflected-ffi/encoder').encoder} [encoder] defines the encoder function to use to encode the result into the SharedArrayBuffer.
+ */
+
+/**
+ * Initialize the worker channel communication and resolves with the worker instance.
+ * @template T
+ * @param {T} Worker
+ * @returns
+ */
+const bootstrap = Worker => {
+  /**
+   * @param {string} scriptURL
+   * @param {Options} options
+   * @returns
+   */
+  return (scriptURL, options) => {
+    const { promise, resolve } = withResolvers$1();
+    // @ts-ignore
+    new Worker(scriptURL, options, resolve);
+    return /** @type {Promise<T>} */(promise);
+  };
+};
+
+const handler$1 = (sab, options, useAtomics) => {
+  const i32a = new Int32Array(sab);
+  const encode = (options.encoder ?? encoder)({ byteOffset });
+  const onsync = options.onsync ?? identity;
+
+  const resolve = (length => {
+      store$1(i32a, 1, length);
+      store$1(i32a, 0, 1);
+      notify(i32a, 0);
+    }) ;
+
+  const process = result => {
+    const length = encode(result, sab);
+    return typeof length === 'number' ? resolve(length) : length.then(resolve);
+  };
+
+  return async ({ data }) => process(await onsync(data));
+};
+
+const isOK = value => {
+  switch (typeof value) {
+    case 'symbol':
+    case 'function':
+      return false;
+  }
+  return true;
+};
+
+const post = (sab, options) => {
+  const opts = {};
+  for (const key in options) {
+    const value = options[key];
+    if (isOK(key) && isOK(value)) opts[key] = value;
+  }
+  return [sab, opts];
+};
+
+const url = (scriptURL, reflected, options) => {
+  const url = new URL(scriptURL, location.href);
+  url.searchParams.set('reflected', reflected);
+  return [url, { ...options, type: 'module' }];
+};
+
+const CHANNEL = 'broadcast';
+
+var main = 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$1(sab, options));
+    super(...url(scriptURL, CHANNEL, options));
+    super.addEventListener('message', () => resolve(this), { once: true });
+    super.postMessage(post(sab, options).concat(channel));
+  }
+
+  get channel() {
+    return CHANNEL;
+  }
+});
+
+//@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;
+};
+
+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 }));
+    }
+  );
+};
+
+const { promise, resolve } = withResolvers$1();
+
+const channel = 'broadcast';
+
+var worker = handler(
+  promise,
+  ({ data: [sab, main, channel] }) => resolve([sab, main, new BroadcastChannel(channel)]),
+);
+
+var broadcast = (
+  'importScripts' in globalThis ? worker : main
+);
+
+export { channel, broadcast as default };