reflected 0.2.5 → 0.2.6

package/dist/proxy/worker/broadcast-DRVfswix.js

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

package/dist/proxy/worker/broadcast-fWsZlH8v.js

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

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

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

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

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

package/dist/proxy/worker/message-Bots8UXM.js

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

package/dist/proxy/worker/message-sej0J6k5.js

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

package/dist/proxy/worker/proxy.js

@@ -1 +1,79 @@
-import{w as a,c as t}from"./shared-DDIlHBz4.js";import{n as e}from"./shared-array-buffer-cwdMr2mc.js";let s,r;if("importScripts"in globalThis){let t;const{promise:e,resolve:n}=a(),o=new URL(location).searchParams.get("reflected");s=o,t="message"===o?import("./message-BvU2dKHz.js"):"broadcast"===o?import("./broadcast-Bdt9gmj_.js"):"xhr"===o?import("./xhr-JKtROQ3y.js"):import("./async-fqI-s7gn.js"),r=async a=>{const{data:s,ports:r}=await e,{default:n}=await t,o=new Event("message");return o.data=s,o.ports=r,dispatchEvent(o),n(a)},addEventListener("message",n,{once:!0})}else e?"InstallTrigger"in globalThis?(s="broadcast",r=(await import("./broadcast-D7rjohJL.js")).default):(s="message",r=(await import("./message-DhtuceT9.js")).default):navigator.serviceWorker?(s="xhr",r=(await import("./xhr-CK-Z6L0B.js")).default):(s="async",r=(await import("./async-Do59YjcF.js").then(function(a){return a.a})).default);var n=r,o=async a=>{const e=t(null),s=await n({...a,onsend:([a,t])=>e[a](...t)});return new Proxy(e,{get(a,t){if("then"!==t)return a[t]??(a[t]=(...a)=>s([t,a]))},set(a,t,e){const s="then"!==t;return s&&(a[t]=e),s}})};export{s as channel,o as default};
+import { w as withResolvers, c as create } from './shared-DR7YYduq.js';
+import { n as native } from './shared-array-buffer-BQgQXQvC.js';
+
+/** @typedef {import('./main/shared.js').Options} MainOptions */
+/** @typedef {import('./worker/shared.js').Options} WorkerOptions */
+
+/** @type {string} */
+let channel;
+
+/** @type {Function} */
+let module$1;
+
+if ('importScripts' in globalThis) {
+  let get;
+  const { promise, resolve } = withResolvers();
+  // @ts-ignore
+  const reflected = new URL(location).searchParams.get('reflected');
+  channel = reflected;
+  if (reflected === 'message') get = import(/* webpackIgnore: true */'./message-Bots8UXM.js');
+  else if (reflected === 'broadcast') get = import(/* webpackIgnore: true */'./broadcast-fWsZlH8v.js');
+  else if (reflected === 'xhr') get = import(/* webpackIgnore: true */'./xhr-DAgmljtu.js');
+  else get = import(/* webpackIgnore: true */'./async-CZJaURwO.js');
+  module$1 = async options => {
+    const { data, ports } = await promise;
+    const { default: reflect } = await get;
+    const event = new Event('message');
+    // @ts-ignore
+    event.data = data;
+    // @ts-ignore
+    event.ports = ports;
+    dispatchEvent(event);
+    return reflect(options);
+  };
+  addEventListener('message', resolve, { once: true });
+}
+else if (native) {
+  if ('InstallTrigger' in globalThis) {
+    channel = 'broadcast';
+    module$1 = (await import(/* webpackIgnore: true */'./broadcast-DRVfswix.js')).default;
+  }
+  else {
+    channel = 'message';
+    module$1 = (await import(/* webpackIgnore: true */'./message-sej0J6k5.js')).default;
+  }
+}
+else if (navigator.serviceWorker) {
+  channel = 'xhr';
+  module$1 = (await import(/* webpackIgnore: true */'./xhr-CQDzS28h.js')).default;
+}
+else {
+  channel = 'async';
+  module$1 = (await import(/* webpackIgnore: true */'./async-DaSAye0a.js').then(function (n) { return n.a; })).default;
+}
+
+var reflected = module$1;
+
+var proxy = async options => {
+  const target = create(null);
+  const send = await reflected({
+    ...options,
+    onsend: ([name, args]) => target[name](...args),
+  });
+  return new Proxy(target, {
+    get(target, name) {
+      // the curse of potentially awaiting proxies in the wild
+      // requires this ugly guard around `then`
+      if (name === 'then') return;
+      return target[name] ?? (target[name] = (...args) => send([name, args]));
+    },
+    // @ts-ignore
+    set(target, name, value) {
+      const ok = name !== 'then';
+      if (ok) target[name] = value;
+      return ok;
+    },
+  });
+};
+
+export { channel, proxy as default };

package/dist/proxy/worker/sender-D5Lm-DmC.js

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