reflected 0.2.4 → 0.2.6

package/dist/shared-L0wiAfqu.js

@@ -0,0 +1,431 @@
+import { w as withResolvers } from './with-resolvers-DsO_nhbc.js';
+import { i as i32 } from './i32-UV5fM9Tw.js';
+import { i as identity, t as SHARED_CHANNEL, w as UNDEFINED, d as dv, c as BIGINT, u as u8a8, S as SYMBOL, x as toSymbol, T as TRUE, j as FALSE, y as encoder$1, p as STRING, B as BLOB, F as FILE, k as REGEXP, m as ImageData, l as IMAGE_DATA, E as ERROR, o as SET, M as MAP, D as DATE, r as BUFFER, z as isView, V as VIEW, C as isArray$1, N as NULL, U as UI8, s as NUMBER, h as NAN, Z as ZERO, e as N_ZERO, g as N_INFINITY, I as INFINITY, R as RECURSION, G as push, a as BIGUINT, O as OBJECT, A as ARRAY, b as byteOffset } from './shared-Ccm1cPah.js';
+
+const { isArray } = 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(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();
+    this.#requests.set(id, resolve);
+    super.postMessage([SHARED_CHANNEL, [id, payload]], ...rest);
+    return promise;
+  }
+}
+
+// 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);
+  }
+}
+
+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 } = 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();
+    // @ts-ignore
+    new Worker(scriptURL, options, resolve);
+    return /** @type {Promise<T>} */(promise);
+  };
+};
+
+const handler = (sab, options, useAtomics) => {
+  const i32a = new Int32Array(sab);
+  const encode = (options.encoder ?? encoder)({ byteOffset });
+  const onsync = options.onsync ?? identity;
+
+  const resolve = useAtomics ?
+    (length => {
+      store(i32a, 1, length);
+      store(i32a, 0, 1);
+      notify(i32a, 0);
+    }) :
+    (length => {
+      i32a[1] = length;
+      i32a[0] = 1;
+    });
+
+  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' }];
+};
+
+export { Sender as S, SAB as a, bootstrap as b, handler as h, post as p, url as u };

package/dist/shared-array-buffer-BQgQXQvC.js

@@ -0,0 +1,28 @@
+//@ts-check
+
+let { SharedArrayBuffer: SAB } = globalThis, native = true;
+
+try {
+  //@ts-ignore due valid options not recognized
+  new SAB(4, { maxByteLength: 8 });
+}
+catch (_) {
+  native = false;
+  SAB = /** @type {SharedArrayBufferConstructor} */(
+    /** @type {unknown} */(
+      class SharedArrayBuffer extends ArrayBuffer {
+        get growable() {
+          //@ts-ignore due valid property not recognized
+          return super.resizable;
+        }
+        /** @param {number} newLength */
+        grow(newLength) {
+          //@ts-ignore due valid method not recognized
+          super.resize(newLength);
+        }
+      }
+    )
+  );
+}
+
+export { SAB as S, native as n };

package/dist/sw.js

@@ -1 +1,155 @@
-const e=Promise.withResolvers||function(){var e,t,n=new this((n,s)=>{e=n,t=s});return{resolve:e,reject:t,promise:n}};var t=e.bind(Promise);const[n,s]=((e=e=>e)=>{const n=new Map,s=(()=>{const e=new Int32Array(1);return()=>e[0]++})();return[()=>{let a;do{a=e(s())}while(n.has(a));const o=t();return n.set(a,o),[a,o.promise]},(e,t,s)=>{const a=n.get(e);n.delete(e),s?a?.reject(s):a?.resolve(t)}]})(),{protocol:a,host:o,pathname:r}=location,i=`${a}//${o}${r}`,c=new BroadcastChannel("fc260aad-4404-43b8-ae9d-2c06554bb294");c.addEventListener("message",({data:[e,t]})=>{if("response"===e){const[e,n]=t;s(e,`[${n.join(",")}]`)}});const d={status:200,statusText:"OK",headers:new Headers({"Cache-Control":"no-cache, must-revalidate",Expires:"Mon, 26 Jul 1997 05:00:00 GMT","Content-type":"application/json"})},l=async e=>{const[t,s]=n();return c.postMessage(["request",[t,e]]),new Response(await s,d)};addEventListener("activate",e=>e.waitUntil(clients.claim())),addEventListener("fetch",async e=>{const{request:t}=e;"POST"===t.method&&t.url.startsWith(i)&&(e.stopImmediatePropagation(),e.respondWith(t.json().then(l)),e.preventDefault())}),addEventListener("install",()=>skipWaiting());
+// shorter: 'fc260aad-4404-43b8-ae9d-2c06554bb294'.split('-').map(s => parseInt(s, 16)).reduce((p, c) => p + c).toString(16)
+var CHANNEL = 'fc260aad-4404-43b8-ae9d-2c06554bb294';
+
+//@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]++;
+};
+
+//@ts-check
+
+
+/**
+ * @template V
+ * @callback Resolve
+ * @param {V?} [value]
+ * @returns {void}
+ */
+
+/**
+ * @callback Reject
+ * @param {any?} [error]
+ * @returns {void}
+ */
+
+/**
+ * @template V
+ * @typedef {object} Resolvers
+ * @prop {Promise<V>} promise
+ * @prop {Resolve<V>} resolve
+ * @prop {Reject} reject
+ */
+
+/**
+ * @template K,V
+ * @typedef {() => [K, Promise<V>]} Next
+ */
+
+/**
+ * @template K,V
+ * @callback Resolver
+ * @param {K} uid
+ * @param {V?} [value]
+ * @param {any?} [error]
+ */
+
+/**
+ * @template K,V
+ * @typedef {[Next<K,V>, Resolver<K,V>]} NextResolver
+ */
+
+/**
+ * @template K,V
+ * @param {(id: number) => K} [as]
+ * @returns
+ */
+var nextResolver = (as = (id => /** @type {K} */(id))) => {
+  /** @type {Map<K,Resolvers<V>>} */
+  const map = new Map;
+  const next = i32();
+  return /** @type {NextResolver<K,V>} */([
+    /** @type {Next<K,V>} */
+    () => {
+      let uid;
+      do { uid = as(next()); }
+      while (map.has(uid));
+      const wr = /** @type {Resolvers<V>} */(/** @type {unknown} */(withResolvers$1()));
+      map.set(uid, wr);
+      return [uid, wr.promise];
+    },
+    /** @type {Resolver<K,V>} */
+    (uid, value, error) => {
+      const wr = map.get(uid);
+      map.delete(uid);
+      if (error) wr?.reject(error);
+      else wr?.resolve(value);
+    },
+  ]);
+};
+
+const [next, resolve] = nextResolver();
+
+const { protocol, host, pathname } = location;
+const url = `${protocol}//${host}${pathname}`;
+
+const bc = new BroadcastChannel(CHANNEL);
+bc.addEventListener('message', ({ data: [op, details] }) => {
+  if (op === 'response') {
+    const [uid, payload] = details;
+    resolve(uid, `[${payload.join(',')}]`);
+  }
+});
+
+const response = {
+  status: 200,
+  statusText: 'OK',
+  headers: new Headers({
+    'Cache-Control': 'no-cache, must-revalidate',
+    'Expires': 'Mon, 26 Jul 1997 05:00:00 GMT',
+    'Content-type': 'application/json',
+  })
+};
+
+const respond = async details => {
+  const [uid, promise] = next();
+  bc.postMessage(['request', [uid, details]]);
+  return new Response(await promise, response);
+};
+
+// @ts-ignore
+const activate = event => event.waitUntil(clients.claim());
+
+const fetch = async event => {
+  const { request: r } = event;
+  if (r.method === 'POST' && r.url.startsWith(url)) {
+    event.stopImmediatePropagation();
+    event.respondWith(r.json().then(respond));
+    event.preventDefault();
+  }
+};
+
+// @ts-ignore
+const install = () => skipWaiting();
+
+addEventListener('activate', activate);
+addEventListener('fetch', fetch);
+addEventListener('install', install);

package/dist/with-resolvers-DsO_nhbc.js

@@ -0,0 +1,24 @@
+//@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);
+
+export { withResolvers$1 as w };