reflected 0.2.4 → 0.2.6

package/dist/ffi/message-Cxjrx_su.js

@@ -0,0 +1,25 @@
+import { b as bootstrap, S as Sender, a as SAB, h as handler, u as url, p as post } from './shared-B3KmQkGh.js';
+import './shared-CjWXp6-D.js';
+import './i32-Cw-Rqr5y.js';
+import './views-DBBYng9N.js';
+import './global-DzpOeFX2.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/ffi/message-mK0eTb54.js

@@ -0,0 +1,15 @@
+import { w as withResolvers } from './shared-CjWXp6-D.js';
+import { h as handler } from './shared-Czh3AlGt.js';
+import './sender-C0gu9RzR.js';
+import './views-DBBYng9N.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/ffi/sender-B7Xmjz4q.js

@@ -0,0 +1,194 @@
+import { F as FILE, B as BLOB, R as RECURSION, S as SYMBOL, 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, f as NAN, T as TRUE, g as FALSE, h as REGEXP, i as IMAGE_DATA, E as ERROR, j as SET, M as MAP, D as DATE, k as STRING, l as decoder$1, m as BUFFER, V as VIEW, A as ARRAY, O as OBJECT, U as UI8, n as NUMBER, u as u8a8 } from './views-C3SJnvMr.js';
+import { e as fromSymbol, I as ImageData, v as defineProperty, S as SHARED_CHANNEL, u as identity } from './shared-5Nhc4gvB.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 };

package/dist/ffi/sender-C0gu9RzR.js

@@ -0,0 +1,194 @@
+import { F as FILE, B as BLOB, R as RECURSION, S as SYMBOL, 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, f as NAN, T as TRUE, g as FALSE, h as REGEXP, i as IMAGE_DATA, j as ImageData, E as ERROR, k as SET, M as MAP, D as DATE, l as STRING, m as decoder$1, n as BUFFER, V as VIEW, A as ARRAY, O as OBJECT, U as UI8, o as NUMBER, u as u8a8 } from './views-DBBYng9N.js';
+import { f as fromSymbol, u as defineProperty, S as SHARED_CHANNEL, s as identity } from './shared-CjWXp6-D.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 };

package/dist/ffi/shared-5Nhc4gvB.js

@@ -0,0 +1,175 @@
+// 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 DIRECT           = 0;
+const REMOTE           = 1 << 0;
+const OBJECT           = 1 << 1;
+const ARRAY            = 1 << 2;
+const FUNCTION         = 1 << 3;
+const SYMBOL           = 1 << 4;
+const BIGINT           = 1 << 5;
+const BUFFER           = 1 << 6;
+
+const VIEW             = BUFFER | ARRAY;
+const REMOTE_OBJECT    = REMOTE | OBJECT;
+const REMOTE_ARRAY     = REMOTE | ARRAY;
+const REMOTE_FUNCTION  = REMOTE | FUNCTION;
+
+class Never {}
+
+const ImageData = globalThis.ImageData || /** @type {typeof ImageData} */(Never);
+
+/** @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 assign$1 = Object.assign;
+
+const fromArray = Array.from;
+
+const isArray = Array.isArray;
+
+const isView = ArrayBuffer.isView;
+
+/**
+ * A type/value pair.
+ * @typedef {[number, any]} TypeValue
+ */
+
+/**
+ * Create a type/value pair.
+ * @param {number} type
+ * @param {any} value
+ * @returns {TypeValue}
+ */
+const tv = (type, value) => [type, value];
+
+const identity$1 = value => value;
+const object = {};
+/* c8 ignore stop */
+
+/**
+ * Create a function that loops through an array and applies a function to each value.
+ * @param {(value:any, cache?:Map<any, any>) => any} asValue
+ * @returns
+ */
+const loopValues = asValue => (
+  /**
+   * Loop through an array and apply a function to each value.
+   * @param {any[]} arr
+   * @param {Map} [cache]
+   * @returns
+   */
+  (arr, cache = new Map) => {
+    for (let i = 0, length = arr.length; i < length; i++)
+      arr[i] = asValue(arr[i], cache);
+    return arr;
+  }
+);
+
+/**
+ * Extract the value from a pair of type and value.
+ * @param {TypeValue} pair
+ * @returns {string|symbol}
+ */
+const fromKey = ([type, value]) => type === DIRECT ? value : fromSymbol(value);
+
+/**
+ * Associate a key with an optionally transformed value.
+ * @param {string|symbol} value
+ * @returns {TypeValue}
+ */
+const toKey = value => typeof value === 'string' ?
+  tv(DIRECT, value) : tv(SYMBOL, toSymbol(value))
+;
+
+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));
+};
+
+//@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);
+
+const assign = Object.assign;
+
+const create = Object.create;
+
+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));
+
+export { ARRAY as A, BIGINT as B, DIRECT as D, FUNCTION as F, ImageData as I, OBJECT as O, REMOTE as R, SHARED_CHANNEL as S, VIEW as V, assign$1 as a, fromKey as b, isArray as c, SYMBOL as d, fromSymbol as e, fromArray as f, toSymbol as g, REMOTE_FUNCTION as h, identity$1 as i, isView as j, BUFFER as k, REMOTE_ARRAY as l, REMOTE_OBJECT as m, loopValues as n, object as o, toKey as p, assign as q, create as r, byteOffset as s, tv as t, identity as u, defineProperty as v, withResolvers$1 as w, randomUUID as x, push as y };