reflected 0.2.4 → 0.2.6

package/dist/message.js

@@ -1 +1,843 @@
-const e=Promise.withResolvers||function(){var e,t,s=new this((s,r)=>{e=s,t=r});return{resolve:e,reject:t,promise:s}};var t=e.bind(Promise),s="fc260aad-4404-43b8-ae9d-2c06554bb294";const r=2*Int32Array.BYTES_PER_ELEMENT;try{crypto.randomUUID()}catch(e){}const n=e=>e,{isArray:a}=Array;class o extends Worker{#e;#t;constructor(e,t){const r=t.onsend??n;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(a(t)&&2===t.length&&t[0]===s){e.stopImmediatePropagation(),e.preventDefault();const[s,n]=t[1],a=this.#t.get(s);this.#t.delete(s),a(await r(n))}})}send(e,...r){const n=this.#e(),{promise:a,resolve:o}=t();return this.#t.set(n,o),super.postMessage([s,[n,e]],...r),a}}let c=0;const i=c++,u=c++,l=c++,h=c++,p=c++,f=c++,y=c++,g=c++,b=c++,d=c++,w=c++,m=c++,v=c++,A=c++,k=c++,S=c++,B=c++,E=c++,M=c++,U=c++,x=c++,I=c++,L=c++,O=c++,T=c++,P=c++,D=c++,F=c++;const N=globalThis.ImageData||class{};class R{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:r}=this.v,n=this.l;this.l+=t,t+=r+n,s.byteLength<t&&s.grow(t),this.v.set(e,n)}}const j=new Map(Reflect.ownKeys(Symbol).map(e=>[Symbol[e],`@${String(e)}`])),q=e=>j.get(e)||((e,t)=>void 0===t?"?":void 0===Symbol.keyFor(e)?`!${t}`:`#${t}`)(e,e.description),_=Object.defineProperty,z=Array.isArray,$=ArrayBuffer.isView,J=new TextDecoder,K=new TextEncoder,V=new ArrayBuffer(8),C=new DataView(V),W=new Uint8Array(V),{getPrototypeOf:Y}=Object,{construct:G}=Reflect,{toStringTag:H}=Symbol,Q=(e,t=e[H])=>t in globalThis?t:Q(G(Y(e.constructor),[0])),{isNaN:X,isFinite:Z,isInteger:ee}=Number,{ownKeys:te}=Reflect,{is:se}=Object,re=(e,t,s)=>{const r=s.get(e),n=!r;return n?(C.setUint32(0,t.length,!0),s.set(e,[W[0],W[1],W[2],W[3]])):t.push(F,r[0],r[1],r[2],r[3]),n},ne=(e,t,s)=>{C.setUint32(0,s,!0),e.push(t,W[0],W[1],W[2],W[3])},ae=(e,t,s)=>{switch(typeof e){case"number":e&&Z(e)?ee(e)&&e<256&&-1<e?t.push(f,e):(C.setFloat64(0,e,!0),t.push(p,W[0],W[1],W[2],W[3],W[4],W[5],W[6],W[7])):X(e)?t.push(y):e?t.push(e<0?b:g):t.push(se(e,0)?d:w);break;case"object":switch(!0){case null===e:t.push(h);break;case!re(e,t,s):break;case z(e):{const r=e.length;ne(t,S,r);for(let n=0;n<r;n++)ae(e[n],t,s);break}case $(e):if(t.push(O),ae(Q(e),t,s),e=e.buffer,!re(e,t,s))break;case e instanceof ArrayBuffer:{const s=new Uint8Array(e);ne(t,B,s.length),ce(t,s);break}case e instanceof Date:t.push(E),ae(e.getTime(),t,s);break;case e instanceof Map:ne(t,U,e.size);for(const[r,n]of e)ae(r,t,s),ae(n,t,s);break;case e instanceof Set:ne(t,L,e.size);for(const r of e)ae(r,t,s);break;case e instanceof Error:t.push(M),ae(e.name,t,s),ae(e.message,t,s),ae(e.stack,t,s);break;case e instanceof N:t.push(T),ae(e.data,t,s),ae(e.width,t,s),ae(e.height,t,s),ae(e.colorSpace,t,s),ae(e.pixelFormat,t,s);break;case e instanceof RegExp:t.push(I),ae(e.source,t,s),ae(e.flags,t,s);break;case e instanceof File:t.push(D),ae(e.name,t,s),ae(e.lastModified,t,s);case e instanceof Blob:{const r=e.size;t.push(P),ae(e.type,t,s),ae(r,t,s);const n=t.length;ce(t,new Uint8Array(r)),oe.push(e.arrayBuffer().then(e=>[n,e]));break}default:if("toJSON"in e){const r=e.toJSON();ae(r===e?null:r,t,s)}else{const r=te(e),n=r.length;ne(t,x,n);for(let a=0;a<n;a++){const n=r[a];ae(n,t,s),ae(e[n],t,s)}}}break;case"string":if(re(e,t,s)){const s=K.encode(e);ne(t,A,s.length),ce(t,s)}break;case"boolean":t.push(e?u:i);break;case"symbol":t.push(k),ae(q(e),t,s);break;case"bigint":{let s=m;9223372036854775807n<e?(C.setBigUint64(0,e,!0),s=v):C.setBigInt64(0,e,!0),t.push(s,W[0],W[1],W[2],W[3],W[4],W[5],W[6],W[7]);break}default:t.push(l)}},oe=[];let ce=(e,t)=>{for(let s=e.push,r=0,n=t.length;r<n;r+=32767)s.apply(e,t.subarray(r,r+32767))};const ie=({byteOffset:e=0,Array:t=R}={})=>(s,r)=>{const n=new t(r,e);ce=t.push,ae(s,n,new Map);const a=n.length;return n.sync(!0),oe.length?Promise.all(oe.splice(0)).then(t=>{const s=new Uint8Array(r,e);for(const[e,r]of t)s.set(new Uint8Array(r),e);return a}):a},{notify:ue,store:le}=Atomics,he=(e,t,s)=>{const a=new Int32Array(e),o=(t.encoder??ie)({byteOffset:r}),c=t.onsync??n,i=e=>{le(a,1,e),le(a,0,1),ue(a,0)};return async({data:t})=>(t=>{const s=o(t,e);return"number"==typeof s?i(s):s.then(i)})(await c(t))},pe=e=>{switch(typeof e){case"symbol":case"function":return!1}return!0},fe="message";var ye=(e=>(s,r)=>{const{promise:n,resolve:a}=t();return new e(s,r,a),n})(class extends o{constructor(e,t,s){const{port1:n,port2:a}=new MessageChannel,o=(({initByteLength:e=1024,maxByteLength:t=8192})=>new SharedArrayBuffer(r+e,{maxByteLength:r+t}))(t);n.addEventListener(fe,he(o,t)),n.start(),super(...((e,t,s)=>{const r=new URL(e,location.href);return r.searchParams.set("reflected",t),[r,{...s,type:"module"}]})(e,fe,t)),super.addEventListener(fe,()=>s(this),{once:!0}),super.postMessage(((e,t)=>{const s={};for(const e in t){const r=t[e];pe(e)&&pe(r)&&(s[e]=r)}return[e,s]})(o,t),[a])}get channel(){return fe}});const ge=(e,t,s)=>(e.set(t,s),s),be=e=>{W[0]=e[me++],W[1]=e[me++],W[2]=e[me++],W[3]=e[me++],W[4]=e[me++],W[5]=e[me++],W[6]=e[me++],W[7]=e[me++]},de=e=>(W[0]=e[me++],W[1]=e[me++],W[2]=e[me++],W[3]=e[me++],C.getUint32(0,!0)),we=(e,t)=>{switch(e[me++]){case p:return be(e),C.getFloat64(0,!0);case f:return e[me++];case x:{const s=ge(t,me-1,{});for(let r=0,n=de(e);r<n;r++)s[we(e,t)]=we(e,t);return s}case S:{const s=ge(t,me-1,[]);for(let r=0,n=de(e);r<n;r++)s.push(we(e,t));return s}case O:{const s=me-1,r=we(e,t);return ge(t,s,new globalThis[r](we(e,t)))}case B:{const s=me-1,r=de(e);return ge(t,s,e.slice(me,me+=r).buffer)}case A:{const s=me-1,r=de(e);return ge(t,s,J.decode(e.slice(me,me+=r)))}case E:return ge(t,me-1,new Date(we(e,t)));case U:{const s=ge(t,me-1,new Map);for(let r=0,n=de(e);r<n;r++)s.set(we(e,t),we(e,t));return s}case L:{const s=ge(t,me-1,new Set);for(let r=0,n=de(e);r<n;r++)s.add(we(e,t));return s}case M:{const s=me-1,r=we(e,t),n=we(e,t),a=we(e,t),o=new(globalThis[r]||Error)(n);return ge(t,s,_(o,"stack",{value:a}))}case T:{const s=me-1,r=we(e,t),n=we(e,t),a=we(e,t),o=we(e,t),c=we(e,t);return ge(t,s,new N(r,n,a,{colorSpace:o,pixelFormat:c}))}case I:{const s=me-1,r=we(e,t),n=we(e,t);return ge(t,s,new RegExp(r,n))}case i:return!1;case u:return!0;case y:return NaN;case g:return 1/0;case b:return-1/0;case d:return 0;case w:return-0;case h:return null;case m:return be(e),C.getBigInt64(0,!0);case v:return be(e),C.getBigUint64(0,!0);case k: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()}})(we(e,t));case F:return t.get(de(e));case P:{const s=me-1,r=we(e,t),n=we(e,t);return ge(t,s,new Blob([e.slice(me,me+=n)],{type:r}))}case D:{const s=me-1,r=we(e,t),n=we(e,t),a=we(e,t);return ge(t,s,new File([a],r,{type:a.type,lastModified:n}))}default:return}};let me=0;const ve=({byteOffset:e=0}={})=>(t,s)=>{return r=new Uint8Array(s,e,t),me=0,we(r,new Map);var r},{isArray:Ae}=Array;const{load:ke,store:Se,wait:Be}=Atomics,{promise:Ee,resolve:Me}=t(),Ue="message";var xe=((e,t)=>(addEventListener("message",t,{once:!0}),t=>e.then(([e,a,o])=>(postMessage(1),((e,t,s)=>{const a=(s.decoder??ve)({byteOffset:r}),o=s.onsync??n,{buffer:c}=t;return(s,...r)=>{e.postMessage(s,...r),Be(t,0,0),Se(t,0,0);const n=ke(t,1);return o(n?a(n,c):void 0)}})(o,new Int32Array(e),(e=>{const t=e.onsend??n;return addEventListener("message",async e=>{const{data:r}=e;if(Ae(r)&&r[0]===s){e.stopImmediatePropagation(),e.preventDefault();const[n,a]=r[1];postMessage([s,[n,await t(a)]])}}),e})({...a,...t}))))))(Ee,({data:[e,t],ports:[s]})=>Me([e,t,s])),Ie="importScripts"in globalThis?xe:ye;export{Ue as channel,Ie 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;
+try {
+  crypto.randomUUID();
+} catch (_) {
+}
+
+const identity = value => value;
+
+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 = 'message';
+
+var main = bootstrap(class Worker extends Sender {
+  constructor(scriptURL, options, resolve) {
+    const { port1, port2 } = new MessageChannel;
+    const sab = SAB(options);
+    port1.addEventListener(CHANNEL, handler$1(sab, options));
+    port1.start();
+    super(...url(scriptURL, CHANNEL, options));
+    super.addEventListener(CHANNEL, () => resolve(this), { once: true });
+    super.postMessage(post(sab, options), [port2]);
+  }
+
+  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 = 'message';
+
+var worker = handler(
+  promise,
+  ({ data: [sab, main], ports: [channel] }) => resolve([sab, main, channel])
+);
+
+var message = (
+  'importScripts' in globalThis ? worker : main
+);
+
+export { channel, message as default };