reflected 0.2.5 → 0.2.6

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

@@ -0,0 +1,431 @@
+import { i as identity, w as withResolvers, b as byteOffset } from './shared-CV7CPYuP.js';
+import { i as i32 } from './i32-UV5fM9Tw.js';
+import { r as SHARED_CHANNEL, s as UNDEFINED, d as dv, b as BIGINT, u as u8a8, S as SYMBOL, t as toSymbol, T as TRUE, h as FALSE, v as encoder$1, n as STRING, B as BLOB, F as FILE, i as REGEXP, k as ImageData, j as IMAGE_DATA, E as ERROR, m as SET, M as MAP, D as DATE, p as BUFFER, w as isView, V as VIEW, x as isArray$1, N as NULL, U as UI8, q as NUMBER, g as NAN, Z as ZERO, c as N_ZERO, e as N_INFINITY, I as INFINITY, R as RECURSION, y as push, a as BIGUINT, O as OBJECT, A as ARRAY } from './channel-NcnPEVL4.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/proxy/main/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/proxy/main/xhr-BUjEbkCh.js

@@ -0,0 +1,100 @@
+import { w as withResolvers, r as randomUUID, b as byteOffset } from './shared-CV7CPYuP.js';
+import { W as Worker$1, S as SAB } from './async-Di4MuQWe.js';
+import { r as SHARED_CHANNEL } from './channel-NcnPEVL4.js';
+import { S as Sender, h as handler, u as url, p as post } from './shared-DdPca9Ke.js';
+import './shared-array-buffer-BQgQXQvC.js';
+import './i32-UV5fM9Tw.js';
+
+const CHANNEL = 'xhr';
+
+const channels = new Map;
+
+const sharedBC = new BroadcastChannel(SHARED_CHANNEL);
+sharedBC.addEventListener('message', async ({ data: [op, details] }) => {
+  if (op === 'request') {
+    const [uid, [id, channel]] = details;
+    const responses = channels.get(channel);
+    if (responses) {
+      const promise = responses.get(id);
+      responses.delete(id);
+      sharedBC.postMessage(['response', [uid, await promise]]);
+    }
+  }
+});
+
+const { promise: sw, resolve } = withResolvers();
+let init = true;
+
+const activate = (swc, options) => {
+  let w, c = true, { url } = options;
+  swc.getRegistration(url)
+    .then(r => (r ?? swc.register(url, options)))
+    .then(function ready(r) {
+      const { controller } = swc;
+      c = c && !!controller;
+      w = (r.installing || r.waiting || r.active);
+      if (!w) return activate(swc, options);
+      if (w.state === 'activated') {
+        if (c) {
+          // allow ServiceWorker swap on different URL
+          if (controller.scriptURL === url)
+            return resolve();
+          r.unregister();
+        }
+        location.reload();
+      }
+      else {
+        w.addEventListener('statechange', () => ready(r), { once: true });
+      }
+    });
+};
+
+class Worker extends Sender {
+  #channel;
+  constructor(scriptURL, options, resolve) {
+    if (init) {
+      init = false;
+      let { serviceWorker } = options;
+      if (!serviceWorker) {
+        // @ts-ignore
+        return new Worker$1(scriptURL, options, resolve);
+      }
+      if (typeof serviceWorker === 'string') serviceWorker = { url: serviceWorker };
+      serviceWorker.url = new URL(serviceWorker.url, location.href).href;
+      activate(navigator.serviceWorker, serviceWorker);
+    }
+    const channel = randomUUID();
+    const bc = new BroadcastChannel(channel);
+    const sab = SAB(options);
+    const responses = new Map;
+    const i32a = new Int32Array(sab);
+    const handle = handler(sab, options, false);
+    channels.set(channel, responses);
+    bc.addEventListener('message', async ({ data: [id, payload] }) => {
+      const { promise, resolve } = withResolvers();
+      responses.set(id, promise);
+      await handle({ data: payload });
+      resolve(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));
+    this.#channel = channel;
+  }
+
+  terminate() {
+    channels.delete(this.#channel);
+    super.terminate();
+  }
+
+  get channel() {
+    return CHANNEL;
+  }
+}
+var xhr = (scriptURL, options) => {
+  const { promise, resolve } = withResolvers();
+  const worker = new Worker(scriptURL, options, resolve);
+  return worker instanceof Worker$1 ? promise : sw.then(() => promise);
+};
+
+export { xhr as default };

package/dist/proxy/main/xhr-WnkM0dVo.js

@@ -0,0 +1,41 @@
+import { w as withResolvers } 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 { parse, stringify } = JSON;
+
+const { promise, resolve } = withResolvers();
+
+addEventListener(
+  'message',
+  ({ data: [_, main, channel] }) => resolve([main, channel]),
+  { once: true }
+);
+
+const channel = 'xhr';
+
+const handle = (channel, options) => {
+  const bc = new BroadcastChannel(channel);
+  const next = i32();
+  const decode = (options.decoder ?? decoder)({ byteOffset: 0 });
+  const { serviceWorker } = options;
+  return (payload, ...rest) => {
+    const id = next();
+    // @ts-ignore
+    bc.postMessage([id, payload], ...rest);
+    const xhr = new XMLHttpRequest;
+    xhr.open('POST', serviceWorker, false);
+    xhr.setRequestHeader('Content-Type', 'application/json');
+    xhr.send(stringify([id, channel]));
+    const { length, buffer } = new Uint8Array(parse(xhr.responseText));
+    return options.onsync(length ? decode(length, buffer) : void 0);
+  };
+};
+
+var xhr = options => promise.then(([main, channel]) => {
+  postMessage(1);
+  return handle(channel, sender({ ...main, ...options }));
+});
+
+export { channel, xhr as default };

package/dist/proxy/worker/async-CZJaURwO.js

@@ -0,0 +1,41 @@
+import { w as withResolvers, b as byteOffset, i as identity } from './shared-DR7YYduq.js';
+import { s as sender, d as decoder } from './sender-D5Lm-DmC.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/worker/async-DaSAye0a.js

@@ -0,0 +1,44 @@
+import { b as bootstrap, S as Sender, h as handler, u as url, p as post } from './shared-CgOGpfKJ.js';
+import { S as SAB$1 } from './shared-array-buffer-BQgQXQvC.js';
+import { b as byteOffset, r as randomUUID } from './shared-DR7YYduq.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 };