@jcubic/mitty 0.1.0

package/dist/index.global.js

@@ -0,0 +1,410 @@
+"use strict";
+var Mitty = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    Host: () => Host,
+    connect: () => connect
+  });
+
+  // src/protocol.ts
+  var HANDLE = /* @__PURE__ */ Symbol.for("@jcubic/mitty/handle");
+  function encode_error(error) {
+    return {
+      type: "error",
+      data: [error.name, error.message, error.stack ?? null]
+    };
+  }
+  function decode_error(marker) {
+    const [name, message, stack] = marker.data;
+    const error = new Error(message);
+    error.name = name;
+    if (stack !== null) {
+      error.stack = stack;
+    }
+    return error;
+  }
+  function is_marker(value) {
+    return typeof value === "object" && value !== null && typeof value.type === "string" && Array.isArray(value.data);
+  }
+  function is_function_marker(value) {
+    return is_marker(value) && value.type === "function";
+  }
+  function is_object_marker(value) {
+    return is_marker(value) && value.type === "object";
+  }
+  function is_error_marker(value) {
+    return is_marker(value) && value.type === "error";
+  }
+  function invalid_handle(id) {
+    return new Error(`mitty: invalid handle #${id} (released or never created)`);
+  }
+
+  // src/host.ts
+  var Host = class {
+    constructor(options) {
+      // objects that cannot cross the channel, kept alive behind an integer id.
+      // there is no GC here - entries live until release() drops them.
+      this._objects = /* @__PURE__ */ new Map();
+      this._object_id = 0;
+      // in-flight invocations of client callbacks, keyed per call (not per
+      // function) so the same callback can be running more than once at a time
+      this._pending = /* @__PURE__ */ new Map();
+      this._call_id = 0;
+      this._options = options;
+      this._channel = options.channel;
+      this._listener = (event) => {
+        void this._on_message(event.data);
+      };
+      this._channel.addEventListener("message", this._listener);
+    }
+    // -------------------------------------------------------------------------
+    // turn a value into a handle the client can call methods on instead of
+    // receiving a copy of. Call this from serialize().
+    // -------------------------------------------------------------------------
+    remote(value) {
+      const id = ++this._object_id;
+      this._objects.set(id, value);
+      return { type: "object", data: [id] };
+    }
+    // -------------------------------------------------------------------------
+    // drop a handle. Returns false if it was already gone.
+    // -------------------------------------------------------------------------
+    release(handle) {
+      const id = typeof handle === "number" ? handle : handle?.data?.[0];
+      if (typeof id !== "number") {
+        throw new TypeError("mitty: release() expects a handle returned by remote()");
+      }
+      return this._objects.delete(id);
+    }
+    // -------------------------------------------------------------------------
+    // stop listening and forget every handle. The channel stays open.
+    // -------------------------------------------------------------------------
+    close() {
+      this._channel.removeEventListener("message", this._listener);
+      this._objects.clear();
+      this._pending.clear();
+    }
+    // -------------------------------------------------------------------------
+    _post(data) {
+      this._channel.postMessage(this._serialize(data));
+    }
+    // -------------------------------------------------------------------------
+    _serialize(data) {
+      const hook = this._options.serialize?.bind(this);
+      return JSON.stringify(data, function(key, value) {
+        const raw = this[key];
+        if (raw instanceof Error) {
+          return encode_error(raw);
+        }
+        const result = hook ? hook(raw) : raw;
+        return result === raw ? value : result;
+      });
+    }
+    // -------------------------------------------------------------------------
+    // Returns null for a message that isn't even JSON - there is nothing to
+    // reply to in that case. A handle that no longer exists is reported as a
+    // deferred error instead of thrown, so the reply can still carry the id
+    // the client is waiting on.
+    // -------------------------------------------------------------------------
+    _unserialize(text) {
+      const hook = this._options.unserialize?.bind(this);
+      let deferred = null;
+      try {
+        const data = JSON.parse(text, (_key, value) => {
+          if (is_function_marker(value)) {
+            const [id, length] = value.data;
+            return this._callback(id, length);
+          }
+          if (is_object_marker(value)) {
+            const [id] = value.data;
+            if (!this._objects.has(id)) {
+              deferred = deferred ?? invalid_handle(id);
+              return void 0;
+            }
+            return this._objects.get(id);
+          }
+          if (is_error_marker(value)) {
+            return decode_error(value);
+          }
+          return hook ? hook(value) : value;
+        });
+        return { data, error: deferred };
+      } catch {
+        return null;
+      }
+    }
+    // -------------------------------------------------------------------------
+    // a stub standing in for a function that lives on the client. Calling it
+    // sends the arguments over and resolves once the client replies.
+    // -------------------------------------------------------------------------
+    _callback(id, length) {
+      return (...args) => {
+        const call = ++this._call_id;
+        return new Promise((resolve, reject) => {
+          this._pending.set(call, { resolve, reject });
+          this._post({ callback: id, call, args: args.slice(0, length) });
+        });
+      };
+    }
+    // -------------------------------------------------------------------------
+    async _on_message(text) {
+      const parsed = this._unserialize(text);
+      if (!parsed) {
+        return;
+      }
+      const { data, error } = parsed;
+      if (typeof data.call === "number" && data.callback === void 0) {
+        const entry = this._pending.get(data.call);
+        if (entry) {
+          this._pending.delete(data.call);
+          if (data.error) {
+            entry.reject(data.error);
+          } else {
+            entry.resolve(data.result);
+          }
+        }
+        return;
+      }
+      if (typeof data.release === "number") {
+        this._objects.delete(data.release);
+        return;
+      }
+      if (typeof data.id !== "number") {
+        return;
+      }
+      try {
+        if (error) {
+          throw error;
+        }
+        this._post({ id: data.id, result: await this._invoke(data) });
+      } catch (thrown) {
+        const failure = thrown instanceof Error ? thrown : new Error(String(thrown));
+        this._post({ id: data.id, error: failure });
+      }
+    }
+    // -------------------------------------------------------------------------
+    // walk the recorded chain against the root in one go, so a whole
+    // expression costs a single message rather than one per step. `object` is
+    // the receiver a call binds to (whatever the value was read off of) and
+    // `value` is the running result.
+    // -------------------------------------------------------------------------
+    async _invoke(data) {
+      const root = await this._root(data);
+      const ops = data.ops ?? [];
+      let object = root;
+      let value = root;
+      let label = typeof data.object === "number" ? `#${data.object}` : data.namespace ?? "";
+      for (const op of ops) {
+        if (op.type === "get") {
+          object = value;
+          value = value?.[op.key];
+          label += `.${op.key}`;
+        } else {
+          if (typeof value !== "function") {
+            throw new TypeError(`mitty: ${label} is not a function`);
+          }
+          value = await value.apply(
+            object,
+            op.args
+          );
+          object = void 0;
+          label += "()";
+        }
+      }
+      return value;
+    }
+    // -------------------------------------------------------------------------
+    async _root(data) {
+      if (typeof data.object === "number") {
+        if (!this._objects.has(data.object)) {
+          throw invalid_handle(data.object);
+        }
+        return this._objects.get(data.object);
+      }
+      if (typeof data.namespace !== "string") {
+        throw new Error("mitty: request has neither a module name nor a handle");
+      }
+      const module = await this._options.resolve(data.namespace);
+      if (module === null || module === void 0) {
+        throw new Error(`mitty: unknown module '${data.namespace}'`);
+      }
+      return module;
+    }
+  };
+
+  // src/client.ts
+  function chain_info(value) {
+    if (value === null || typeof value !== "object" && typeof value !== "function") {
+      return void 0;
+    }
+    return value[HANDLE];
+  }
+  function connect(channel) {
+    let rpc_id = 0;
+    let callback_id = 0;
+    const pending = /* @__PURE__ */ new Map();
+    const callbacks = /* @__PURE__ */ new Map();
+    const callback_ids = /* @__PURE__ */ new Map();
+    function serialize(data) {
+      return JSON.stringify(data, function(key, value) {
+        const raw = this[key];
+        if (raw instanceof Error) {
+          return encode_error(raw);
+        }
+        const chain = chain_info(raw);
+        if (chain) {
+          if (chain.ops.length || typeof chain.root.object !== "number") {
+            throw new TypeError(
+              "mitty: cannot send an unresolved remote chain - await it first"
+            );
+          }
+          return { type: "object", data: [chain.root.object] };
+        }
+        if (typeof raw === "function") {
+          let id = callback_ids.get(raw);
+          if (id === void 0) {
+            id = ++callback_id;
+            callback_ids.set(raw, id);
+            callbacks.set(id, raw);
+          }
+          return { type: "function", data: [id, raw.length] };
+        }
+        return value;
+      });
+    }
+    function unserialize(text) {
+      return JSON.parse(text, (_key, value) => {
+        if (is_object_marker(value)) {
+          return make_chain({ object: value.data[0] });
+        }
+        if (is_error_marker(value)) {
+          return decode_error(value);
+        }
+        return value;
+      });
+    }
+    function post(data) {
+      channel.postMessage(serialize(data));
+    }
+    async function run_callback(data) {
+      const fn = callbacks.get(data.callback);
+      if (!fn || typeof data.call !== "number") {
+        return;
+      }
+      try {
+        post({ call: data.call, result: await fn(...data.args ?? []) });
+      } catch (error) {
+        post({ call: data.call, error });
+      }
+    }
+    const listener = (event) => {
+      let data;
+      try {
+        data = unserialize(event.data);
+      } catch {
+        return;
+      }
+      if (typeof data.callback === "number") {
+        void run_callback(data);
+        return;
+      }
+      if (typeof data.id !== "number") {
+        return;
+      }
+      const entry = pending.get(data.id);
+      if (!entry) {
+        return;
+      }
+      pending.delete(data.id);
+      if (data.error) {
+        entry.reject(data.error);
+      } else {
+        entry.resolve(data.result);
+      }
+    };
+    channel.addEventListener("message", listener);
+    function call(root, ops) {
+      return new Promise((resolve, reject) => {
+        const id = ++rpc_id;
+        let payload;
+        try {
+          payload = serialize({ id, ...root, ops });
+        } catch (error) {
+          reject(error);
+          return;
+        }
+        pending.set(id, { resolve, reject });
+        channel.postMessage(payload);
+      });
+    }
+    function make_chain(root, ops = []) {
+      const target = function() {
+      };
+      return new Proxy(target, {
+        apply(_target, _this_arg, args) {
+          return make_chain(root, [...ops, { type: "call", args }]);
+        },
+        get(_target, key) {
+          if (key === HANDLE) {
+            return { root, ops };
+          }
+          if (key === "then") {
+            if (!ops.length) {
+              return void 0;
+            }
+            return (resolve, reject) => call(root, ops).then(resolve, reject);
+          }
+          if (typeof key !== "string") {
+            return void 0;
+          }
+          return make_chain(root, [...ops, { type: "get", key }]);
+        }
+      });
+    }
+    function handle_id(remote) {
+      const chain = chain_info(remote);
+      if (!chain || chain.ops.length || typeof chain.root.object !== "number") {
+        throw new TypeError("mitty: expected a remote handle");
+      }
+      return chain.root.object;
+    }
+    return {
+      require(name) {
+        return make_chain({ namespace: name });
+      },
+      handle(remote) {
+        return handle_id(remote);
+      },
+      release(remote) {
+        post({ release: typeof remote === "number" ? remote : handle_id(remote) });
+      },
+      close() {
+        channel.removeEventListener("message", listener);
+        pending.clear();
+        callbacks.clear();
+        callback_ids.clear();
+      }
+    };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map

package/dist/index.global.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/protocol.ts","../src/host.ts","../src/client.ts"],"sourcesContent":["export { Host } from './host';\nexport type { HostOptions } from './host';\nexport { connect } from './client';\nexport type {\n    Channel,\n    ChannelEvent,\n    ChannelListener,\n    Client,\n    ErrorMarker,\n    FunctionMarker,\n    Marker,\n    ObjectMarker,\n    Op,\n    Remote,\n} from './types';\n","import type { ErrorMarker, FunctionMarker, Marker, ObjectMarker } from './types';\n\n// key used to read the root/ops out of a chain proxy without going through the\n// get trap's normal \"record another step\" behaviour. Symbol.for() so two copies\n// of the library (e.g. a bundled one and one from a CDN) still recognise each\n// other's proxies.\nexport const HANDLE = Symbol.for('@jcubic/mitty/handle');\n\nexport function encode_error(error: Error): ErrorMarker {\n    return {\n        type: 'error',\n        data: [error.name, error.message, error.stack ?? null],\n    };\n}\n\nexport function decode_error(marker: ErrorMarker): Error {\n    const [name, message, stack] = marker.data;\n    const error = new Error(message);\n    error.name = name;\n    if (stack !== null) {\n        // keep the host's stack - it points at where the call actually failed,\n        // which is far more useful than a stack inside this library\n        error.stack = stack;\n    }\n    return error;\n}\n\nfunction is_marker(value: unknown): value is Marker {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        typeof (value as Marker).type === 'string' &&\n        Array.isArray((value as Marker).data)\n    );\n}\n\nexport function is_function_marker(value: unknown): value is FunctionMarker {\n    return is_marker(value) && value.type === 'function';\n}\n\nexport function is_object_marker(value: unknown): value is ObjectMarker {\n    return is_marker(value) && value.type === 'object';\n}\n\nexport function is_error_marker(value: unknown): value is ErrorMarker {\n    return is_marker(value) && value.type === 'error';\n}\n\nexport function invalid_handle(id: number): Error {\n    return new Error(`mitty: invalid handle #${id} (released or never created)`);\n}\n","import {\n    decode_error,\n    encode_error,\n    invalid_handle,\n    is_error_marker,\n    is_function_marker,\n    is_object_marker,\n} from './protocol';\nimport type { Channel, ChannelListener, ObjectMarker, Op } from './types';\n\nexport interface HostOptions {\n    // the transport this host listens on; the host never closes it\n    channel: Channel;\n    // turn a module name from require() into the value the chain runs against.\n    // Return null/undefined for an unknown name. May be async.\n    resolve(name: string): unknown;\n    // called for every value on its way out. Return this.remote(value) for\n    // anything that cannot survive JSON (DOM nodes, jQuery objects, class\n    // instances with methods), otherwise return the value untouched.\n    serialize?(this: Host, value: unknown): unknown;\n    // called for every value coming in from the client\n    unserialize?(this: Host, value: unknown): unknown;\n}\n\ninterface Message {\n    id?: number;\n    namespace?: string;\n    object?: number;\n    ops?: Op[];\n    callback?: number;\n    call?: number;\n    args?: unknown[];\n    result?: unknown;\n    error?: unknown;\n    release?: number;\n}\n\ntype Resolver = { resolve: (value: unknown) => void; reject: (reason: unknown) => void };\n\nexport class Host {\n    private _options: HostOptions;\n    private _channel: Channel;\n    private _listener: ChannelListener;\n    // objects that cannot cross the channel, kept alive behind an integer id.\n    // there is no GC here - entries live until release() drops them.\n    private _objects = new Map<number, unknown>();\n    private _object_id = 0;\n    // in-flight invocations of client callbacks, keyed per call (not per\n    // function) so the same callback can be running more than once at a time\n    private _pending = new Map<number, Resolver>();\n    private _call_id = 0;\n\n    constructor(options: HostOptions) {\n        this._options = options;\n        this._channel = options.channel;\n        this._listener = event => {\n            void this._on_message(event.data);\n        };\n        this._channel.addEventListener('message', this._listener);\n    }\n\n    // -------------------------------------------------------------------------\n    // turn a value into a handle the client can call methods on instead of\n    // receiving a copy of. Call this from serialize().\n    // -------------------------------------------------------------------------\n    public remote(value: unknown): ObjectMarker {\n        const id = ++this._object_id;\n        this._objects.set(id, value);\n        return { type: 'object', data: [id] };\n    }\n\n    // -------------------------------------------------------------------------\n    // drop a handle. Returns false if it was already gone.\n    // -------------------------------------------------------------------------\n    public release(handle: ObjectMarker | number): boolean {\n        const id = typeof handle === 'number' ? handle : handle?.data?.[0];\n        if (typeof id !== 'number') {\n            throw new TypeError('mitty: release() expects a handle returned by remote()');\n        }\n        return this._objects.delete(id);\n    }\n\n    // -------------------------------------------------------------------------\n    // stop listening and forget every handle. The channel stays open.\n    // -------------------------------------------------------------------------\n    public close(): void {\n        this._channel.removeEventListener('message', this._listener);\n        this._objects.clear();\n        this._pending.clear();\n    }\n\n    // -------------------------------------------------------------------------\n    private _post(data: Message): void {\n        this._channel.postMessage(this._serialize(data));\n    }\n\n    // -------------------------------------------------------------------------\n    private _serialize(data: Message): string {\n        // bound here because the replacer has to be a plain function - its\n        // `this` is the holder object, not the Host\n        const hook = this._options.serialize?.bind(this);\n        return JSON.stringify(data, function (this: Record<string, unknown>, key, value) {\n            // read the untouched value off the holder: by the time a replacer\n            // runs, JSON.stringify has already swapped in the result of any\n            // toJSON(), which hides what we need to recognise\n            const raw = this[key];\n            if (raw instanceof Error) {\n                return encode_error(raw);\n            }\n            const result = hook ? hook(raw) : raw;\n            // when the hook passes a value through, fall back to `value` so\n            // ordinary JSON conventions (Date#toJSON and friends) still apply\n            return result === raw ? value : result;\n        });\n    }\n\n    // -------------------------------------------------------------------------\n    // Returns null for a message that isn't even JSON - there is nothing to\n    // reply to in that case. A handle that no longer exists is reported as a\n    // deferred error instead of thrown, so the reply can still carry the id\n    // the client is waiting on.\n    // -------------------------------------------------------------------------\n    private _unserialize(text: string): { data: Message; error: Error | null } | null {\n        const hook = this._options.unserialize?.bind(this);\n        let deferred: Error | null = null;\n        try {\n            const data = JSON.parse(text, (_key, value) => {\n                if (is_function_marker(value)) {\n                    const [id, length] = value.data;\n                    return this._callback(id, length);\n                }\n                if (is_object_marker(value)) {\n                    const [id] = value.data;\n                    if (!this._objects.has(id)) {\n                        deferred = deferred ?? invalid_handle(id);\n                        return undefined;\n                    }\n                    return this._objects.get(id);\n                }\n                if (is_error_marker(value)) {\n                    return decode_error(value);\n                }\n                return hook ? hook(value) : value;\n            }) as Message;\n            return { data, error: deferred };\n        } catch {\n            return null;\n        }\n    }\n\n    // -------------------------------------------------------------------------\n    // a stub standing in for a function that lives on the client. Calling it\n    // sends the arguments over and resolves once the client replies.\n    // -------------------------------------------------------------------------\n    private _callback(id: number, length: number) {\n        return (...args: unknown[]): Promise<unknown> => {\n            const call = ++this._call_id;\n            return new Promise((resolve, reject) => {\n                this._pending.set(call, { resolve, reject });\n                // trim to the declared arity: callers like jQuery pass extras\n                // (event objects, indexes) that usually cannot be serialized\n                this._post({ callback: id, call, args: args.slice(0, length) });\n            });\n        };\n    }\n\n    // -------------------------------------------------------------------------\n    private async _on_message(text: string): Promise<void> {\n        const parsed = this._unserialize(text);\n        if (!parsed) {\n            return;\n        }\n        const { data, error } = parsed;\n\n        // a client callback finished - `callback` is absent, which is what\n        // distinguishes a result coming back from an invocation going out\n        if (typeof data.call === 'number' && data.callback === undefined) {\n            const entry = this._pending.get(data.call);\n            if (entry) {\n                this._pending.delete(data.call);\n                if (data.error) {\n                    entry.reject(data.error);\n                } else {\n                    entry.resolve(data.result);\n                }\n            }\n            return;\n        }\n\n        if (typeof data.release === 'number') {\n            this._objects.delete(data.release);\n            return;\n        }\n\n        if (typeof data.id !== 'number') {\n            return;\n        }\n\n        try {\n            if (error) {\n                throw error;\n            }\n            this._post({ id: data.id, result: await this._invoke(data) });\n        } catch (thrown) {\n            const failure = thrown instanceof Error ? thrown : new Error(String(thrown));\n            this._post({ id: data.id, error: failure });\n        }\n    }\n\n    // -------------------------------------------------------------------------\n    // walk the recorded chain against the root in one go, so a whole\n    // expression costs a single message rather than one per step. `object` is\n    // the receiver a call binds to (whatever the value was read off of) and\n    // `value` is the running result.\n    // -------------------------------------------------------------------------\n    private async _invoke(data: Message): Promise<unknown> {\n        const root = await this._root(data);\n        const ops = data.ops ?? [];\n        let object: unknown = root;\n        let value: unknown = root;\n        let label =\n            typeof data.object === 'number' ? `#${data.object}` : (data.namespace ?? '');\n        for (const op of ops) {\n            if (op.type === 'get') {\n                object = value;\n                value = (value as Record<string, unknown> | null | undefined)?.[op.key];\n                label += `.${op.key}`;\n            } else {\n                if (typeof value !== 'function') {\n                    throw new TypeError(`mitty: ${label} is not a function`);\n                }\n                value = await (value as (...args: unknown[]) => unknown).apply(\n                    object,\n                    op.args,\n                );\n                // a result is not bound to anything until it is read off\n                // something else, so the next call has no receiver\n                object = undefined;\n                label += '()';\n            }\n        }\n        return value;\n    }\n\n    // -------------------------------------------------------------------------\n    private async _root(data: Message): Promise<unknown> {\n        if (typeof data.object === 'number') {\n            if (!this._objects.has(data.object)) {\n                throw invalid_handle(data.object);\n            }\n            return this._objects.get(data.object);\n        }\n        if (typeof data.namespace !== 'string') {\n            throw new Error('mitty: request has neither a module name nor a handle');\n        }\n        const module = await this._options.resolve(data.namespace);\n        if (module === null || module === undefined) {\n            throw new Error(`mitty: unknown module '${data.namespace}'`);\n        }\n        return module;\n    }\n}\n","import {\n    HANDLE,\n    decode_error,\n    encode_error,\n    is_error_marker,\n    is_object_marker,\n} from './protocol';\nimport type { Channel, ChannelListener, Client, Op, Remote } from './types';\n\n// what a chain is rooted at: a module looked up by name, or an object that\n// stayed behind on the host\ninterface Root {\n    namespace?: string;\n    object?: number;\n}\n\ninterface ChainInfo {\n    root: Root;\n    ops: Op[];\n}\n\ninterface Message {\n    id?: number;\n    callback?: number;\n    call?: number;\n    args?: unknown[];\n    result?: unknown;\n    error?: unknown;\n    release?: number;\n}\n\ntype Callback = (...args: unknown[]) => unknown;\n\nfunction chain_info(value: unknown): ChainInfo | undefined {\n    if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {\n        return undefined;\n    }\n    return (value as Record<symbol, ChainInfo | undefined>)[HANDLE];\n}\n\n// -----------------------------------------------------------------------------\n// Connect to a Host listening on the other end of `channel`. Safe to call in a\n// worker loaded with either `import` or `importScripts`.\n// -----------------------------------------------------------------------------\nexport function connect(channel: Channel): Client {\n    let rpc_id = 0;\n    let callback_id = 0;\n    const pending = new Map<\n        number,\n        { resolve: (value: unknown) => void; reject: (reason: unknown) => void }\n    >();\n    // functions handed to the host, so it can call back into this worker.\n    // keyed both ways to reuse an id when the same function is passed twice.\n    const callbacks = new Map<number, Callback>();\n    const callback_ids = new Map<Callback, number>();\n\n    function serialize(data: unknown): string {\n        return JSON.stringify(data, function (this: Record<string, unknown>, key, value) {\n            // the raw holder value, before JSON.stringify applied toJSON() -\n            // a chain proxy answers every property access, toJSON included\n            const raw = this[key];\n            if (raw instanceof Error) {\n                return encode_error(raw);\n            }\n            const chain = chain_info(raw);\n            if (chain) {\n                if (chain.ops.length || typeof chain.root.object !== 'number') {\n                    throw new TypeError(\n                        'mitty: cannot send an unresolved remote chain - await it first',\n                    );\n                }\n                // a handle can go back to the host, which swaps it for the\n                // object it stands for\n                return { type: 'object', data: [chain.root.object] };\n            }\n            if (typeof raw === 'function') {\n                let id = callback_ids.get(raw as Callback);\n                if (id === undefined) {\n                    id = ++callback_id;\n                    callback_ids.set(raw as Callback, id);\n                    callbacks.set(id, raw as Callback);\n                }\n                return { type: 'function', data: [id, raw.length] };\n            }\n            return value;\n        });\n    }\n\n    function unserialize(text: string): Message {\n        return JSON.parse(text, (_key, value) => {\n            if (is_object_marker(value)) {\n                // a handle to something on the host - make it a chain rooted\n                // there rather than handing back the marker itself\n                return make_chain({ object: value.data[0] });\n            }\n            if (is_error_marker(value)) {\n                return decode_error(value);\n            }\n            return value;\n        }) as Message;\n    }\n\n    function post(data: Message): void {\n        channel.postMessage(serialize(data));\n    }\n\n    async function run_callback(data: Message): Promise<void> {\n        const fn = callbacks.get(data.callback as number);\n        if (!fn || typeof data.call !== 'number') {\n            return;\n        }\n        try {\n            post({ call: data.call, result: await fn(...(data.args ?? [])) });\n        } catch (error) {\n            post({ call: data.call, error });\n        }\n    }\n\n    const listener: ChannelListener = event => {\n        let data: Message;\n        try {\n            data = unserialize(event.data);\n        } catch {\n            return;\n        }\n        if (typeof data.callback === 'number') {\n            void run_callback(data);\n            return;\n        }\n        if (typeof data.id !== 'number') {\n            return;\n        }\n        const entry = pending.get(data.id);\n        if (!entry) {\n            return;\n        }\n        pending.delete(data.id);\n        if (data.error) {\n            entry.reject(data.error);\n        } else {\n            entry.resolve(data.result);\n        }\n    };\n\n    channel.addEventListener('message', listener);\n\n    function call(root: Root, ops: Op[]): Promise<unknown> {\n        return new Promise((resolve, reject) => {\n            const id = ++rpc_id;\n            let payload: string;\n            try {\n                payload = serialize({ id, ...root, ops });\n            } catch (error) {\n                // an argument that cannot be sent (an unresolved chain, a\n                // circular structure) fails the call rather than the channel\n                reject(error);\n                return;\n            }\n            pending.set(id, { resolve, reject });\n            channel.postMessage(payload);\n        });\n    }\n\n    // -------------------------------------------------------------------------\n    // Records property accesses and calls without touching the channel. The\n    // whole chain is sent once, when something awaits it.\n    // -------------------------------------------------------------------------\n    function make_chain(root: Root, ops: Op[] = []): Remote {\n        const target = function () {} as unknown as Remote;\n        return new Proxy(target, {\n            apply(_target, _this_arg, args: unknown[]) {\n                return make_chain(root, [...ops, { type: 'call', args }]);\n            },\n            get(_target, key) {\n                if (key === HANDLE) {\n                    return { root, ops };\n                }\n                if (key === 'then') {\n                    // becoming a real thenable is what triggers execution.\n                    // Only do that when there is something to run: a bare\n                    // handle (no ops yet) has to stay non-thenable, because it\n                    // resolves to another handle and promise resolution would\n                    // otherwise keep adopting it forever.\n                    if (!ops.length) {\n                        return undefined;\n                    }\n                    return (\n                        resolve: (value: unknown) => void,\n                        reject: (reason: unknown) => void,\n                    ) => call(root, ops).then(resolve, reject);\n                }\n                if (typeof key !== 'string') {\n                    return undefined;\n                }\n                return make_chain(root, [...ops, { type: 'get', key }]);\n            },\n        });\n    }\n\n    // the host-side id a bare handle stands for. A chain that still has ops, or\n    // one rooted at a module, does not name a single object.\n    function handle_id(remote: unknown): number {\n        const chain = chain_info(remote);\n        if (!chain || chain.ops.length || typeof chain.root.object !== 'number') {\n            throw new TypeError('mitty: expected a remote handle');\n        }\n        return chain.root.object;\n    }\n\n    return {\n        require(name: string): Remote {\n            return make_chain({ namespace: name });\n        },\n        handle(remote: unknown): number {\n            return handle_id(remote);\n        },\n        release(remote: unknown): void {\n            post({ release: typeof remote === 'number' ? remote : handle_id(remote) });\n        },\n        close(): void {\n            channel.removeEventListener('message', listener);\n            pending.clear();\n            callbacks.clear();\n            callback_ids.clear();\n        },\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMO,MAAM,SAAS,uBAAO,IAAI,sBAAsB;AAEhD,WAAS,aAAa,OAA2B;AACpD,WAAO;AAAA,MACH,MAAM;AAAA,MACN,MAAM,CAAC,MAAM,MAAM,MAAM,SAAS,MAAM,SAAS,IAAI;AAAA,IACzD;AAAA,EACJ;AAEO,WAAS,aAAa,QAA4B;AACrD,UAAM,CAAC,MAAM,SAAS,KAAK,IAAI,OAAO;AACtC,UAAM,QAAQ,IAAI,MAAM,OAAO;AAC/B,UAAM,OAAO;AACb,QAAI,UAAU,MAAM;AAGhB,YAAM,QAAQ;AAAA,IAClB;AACA,WAAO;AAAA,EACX;AAEA,WAAS,UAAU,OAAiC;AAChD,WACI,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAiB,SAAS,YAClC,MAAM,QAAS,MAAiB,IAAI;AAAA,EAE5C;AAEO,WAAS,mBAAmB,OAAyC;AACxE,WAAO,UAAU,KAAK,KAAK,MAAM,SAAS;AAAA,EAC9C;AAEO,WAAS,iBAAiB,OAAuC;AACpE,WAAO,UAAU,KAAK,KAAK,MAAM,SAAS;AAAA,EAC9C;AAEO,WAAS,gBAAgB,OAAsC;AAClE,WAAO,UAAU,KAAK,KAAK,MAAM,SAAS;AAAA,EAC9C;AAEO,WAAS,eAAe,IAAmB;AAC9C,WAAO,IAAI,MAAM,0BAA0B,EAAE,8BAA8B;AAAA,EAC/E;;;ACXO,MAAM,OAAN,MAAW;AAAA,IAad,YAAY,SAAsB;AAPlC;AAAA;AAAA,WAAQ,WAAW,oBAAI,IAAqB;AAC5C,WAAQ,aAAa;AAGrB;AAAA;AAAA,WAAQ,WAAW,oBAAI,IAAsB;AAC7C,WAAQ,WAAW;AAGf,WAAK,WAAW;AAChB,WAAK,WAAW,QAAQ;AACxB,WAAK,YAAY,WAAS;AACtB,aAAK,KAAK,YAAY,MAAM,IAAI;AAAA,MACpC;AACA,WAAK,SAAS,iBAAiB,WAAW,KAAK,SAAS;AAAA,IAC5D;AAAA;AAAA;AAAA;AAAA;AAAA,IAMO,OAAO,OAA8B;AACxC,YAAM,KAAK,EAAE,KAAK;AAClB,WAAK,SAAS,IAAI,IAAI,KAAK;AAC3B,aAAO,EAAE,MAAM,UAAU,MAAM,CAAC,EAAE,EAAE;AAAA,IACxC;AAAA;AAAA;AAAA;AAAA,IAKO,QAAQ,QAAwC;AACnD,YAAM,KAAK,OAAO,WAAW,WAAW,SAAS,QAAQ,OAAO,CAAC;AACjE,UAAI,OAAO,OAAO,UAAU;AACxB,cAAM,IAAI,UAAU,wDAAwD;AAAA,MAChF;AACA,aAAO,KAAK,SAAS,OAAO,EAAE;AAAA,IAClC;AAAA;AAAA;AAAA;AAAA,IAKO,QAAc;AACjB,WAAK,SAAS,oBAAoB,WAAW,KAAK,SAAS;AAC3D,WAAK,SAAS,MAAM;AACpB,WAAK,SAAS,MAAM;AAAA,IACxB;AAAA;AAAA,IAGQ,MAAM,MAAqB;AAC/B,WAAK,SAAS,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,IACnD;AAAA;AAAA,IAGQ,WAAW,MAAuB;AAGtC,YAAM,OAAO,KAAK,SAAS,WAAW,KAAK,IAAI;AAC/C,aAAO,KAAK,UAAU,MAAM,SAAyC,KAAK,OAAO;AAI7E,cAAM,MAAM,KAAK,GAAG;AACpB,YAAI,eAAe,OAAO;AACtB,iBAAO,aAAa,GAAG;AAAA,QAC3B;AACA,cAAM,SAAS,OAAO,KAAK,GAAG,IAAI;AAGlC,eAAO,WAAW,MAAM,QAAQ;AAAA,MACpC,CAAC;AAAA,IACL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQQ,aAAa,MAA6D;AAC9E,YAAM,OAAO,KAAK,SAAS,aAAa,KAAK,IAAI;AACjD,UAAI,WAAyB;AAC7B,UAAI;AACA,cAAM,OAAO,KAAK,MAAM,MAAM,CAAC,MAAM,UAAU;AAC3C,cAAI,mBAAmB,KAAK,GAAG;AAC3B,kBAAM,CAAC,IAAI,MAAM,IAAI,MAAM;AAC3B,mBAAO,KAAK,UAAU,IAAI,MAAM;AAAA,UACpC;AACA,cAAI,iBAAiB,KAAK,GAAG;AACzB,kBAAM,CAAC,EAAE,IAAI,MAAM;AACnB,gBAAI,CAAC,KAAK,SAAS,IAAI,EAAE,GAAG;AACxB,yBAAW,YAAY,eAAe,EAAE;AACxC,qBAAO;AAAA,YACX;AACA,mBAAO,KAAK,SAAS,IAAI,EAAE;AAAA,UAC/B;AACA,cAAI,gBAAgB,KAAK,GAAG;AACxB,mBAAO,aAAa,KAAK;AAAA,UAC7B;AACA,iBAAO,OAAO,KAAK,KAAK,IAAI;AAAA,QAChC,CAAC;AACD,eAAO,EAAE,MAAM,OAAO,SAAS;AAAA,MACnC,QAAQ;AACJ,eAAO;AAAA,MACX;AAAA,IACJ;AAAA;AAAA;AAAA;AAAA;AAAA,IAMQ,UAAU,IAAY,QAAgB;AAC1C,aAAO,IAAI,SAAsC;AAC7C,cAAM,OAAO,EAAE,KAAK;AACpB,eAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACpC,eAAK,SAAS,IAAI,MAAM,EAAE,SAAS,OAAO,CAAC;AAG3C,eAAK,MAAM,EAAE,UAAU,IAAI,MAAM,MAAM,KAAK,MAAM,GAAG,MAAM,EAAE,CAAC;AAAA,QAClE,CAAC;AAAA,MACL;AAAA,IACJ;AAAA;AAAA,IAGA,MAAc,YAAY,MAA6B;AACnD,YAAM,SAAS,KAAK,aAAa,IAAI;AACrC,UAAI,CAAC,QAAQ;AACT;AAAA,MACJ;AACA,YAAM,EAAE,MAAM,MAAM,IAAI;AAIxB,UAAI,OAAO,KAAK,SAAS,YAAY,KAAK,aAAa,QAAW;AAC9D,cAAM,QAAQ,KAAK,SAAS,IAAI,KAAK,IAAI;AACzC,YAAI,OAAO;AACP,eAAK,SAAS,OAAO,KAAK,IAAI;AAC9B,cAAI,KAAK,OAAO;AACZ,kBAAM,OAAO,KAAK,KAAK;AAAA,UAC3B,OAAO;AACH,kBAAM,QAAQ,KAAK,MAAM;AAAA,UAC7B;AAAA,QACJ;AACA;AAAA,MACJ;AAEA,UAAI,OAAO,KAAK,YAAY,UAAU;AAClC,aAAK,SAAS,OAAO,KAAK,OAAO;AACjC;AAAA,MACJ;AAEA,UAAI,OAAO,KAAK,OAAO,UAAU;AAC7B;AAAA,MACJ;AAEA,UAAI;AACA,YAAI,OAAO;AACP,gBAAM;AAAA,QACV;AACA,aAAK,MAAM,EAAE,IAAI,KAAK,IAAI,QAAQ,MAAM,KAAK,QAAQ,IAAI,EAAE,CAAC;AAAA,MAChE,SAAS,QAAQ;AACb,cAAM,UAAU,kBAAkB,QAAQ,SAAS,IAAI,MAAM,OAAO,MAAM,CAAC;AAC3E,aAAK,MAAM,EAAE,IAAI,KAAK,IAAI,OAAO,QAAQ,CAAC;AAAA,MAC9C;AAAA,IACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,MAAc,QAAQ,MAAiC;AACnD,YAAM,OAAO,MAAM,KAAK,MAAM,IAAI;AAClC,YAAM,MAAM,KAAK,OAAO,CAAC;AACzB,UAAI,SAAkB;AACtB,UAAI,QAAiB;AACrB,UAAI,QACA,OAAO,KAAK,WAAW,WAAW,IAAI,KAAK,MAAM,KAAM,KAAK,aAAa;AAC7E,iBAAW,MAAM,KAAK;AAClB,YAAI,GAAG,SAAS,OAAO;AACnB,mBAAS;AACT,kBAAS,QAAuD,GAAG,GAAG;AACtE,mBAAS,IAAI,GAAG,GAAG;AAAA,QACvB,OAAO;AACH,cAAI,OAAO,UAAU,YAAY;AAC7B,kBAAM,IAAI,UAAU,UAAU,KAAK,oBAAoB;AAAA,UAC3D;AACA,kBAAQ,MAAO,MAA0C;AAAA,YACrD;AAAA,YACA,GAAG;AAAA,UACP;AAGA,mBAAS;AACT,mBAAS;AAAA,QACb;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA;AAAA,IAGA,MAAc,MAAM,MAAiC;AACjD,UAAI,OAAO,KAAK,WAAW,UAAU;AACjC,YAAI,CAAC,KAAK,SAAS,IAAI,KAAK,MAAM,GAAG;AACjC,gBAAM,eAAe,KAAK,MAAM;AAAA,QACpC;AACA,eAAO,KAAK,SAAS,IAAI,KAAK,MAAM;AAAA,MACxC;AACA,UAAI,OAAO,KAAK,cAAc,UAAU;AACpC,cAAM,IAAI,MAAM,uDAAuD;AAAA,MAC3E;AACA,YAAM,SAAS,MAAM,KAAK,SAAS,QAAQ,KAAK,SAAS;AACzD,UAAI,WAAW,QAAQ,WAAW,QAAW;AACzC,cAAM,IAAI,MAAM,0BAA0B,KAAK,SAAS,GAAG;AAAA,MAC/D;AACA,aAAO;AAAA,IACX;AAAA,EACJ;;;ACpOA,WAAS,WAAW,OAAuC;AACvD,QAAI,UAAU,QAAS,OAAO,UAAU,YAAY,OAAO,UAAU,YAAa;AAC9E,aAAO;AAAA,IACX;AACA,WAAQ,MAAgD,MAAM;AAAA,EAClE;AAMO,WAAS,QAAQ,SAA0B;AAC9C,QAAI,SAAS;AACb,QAAI,cAAc;AAClB,UAAM,UAAU,oBAAI,IAGlB;AAGF,UAAM,YAAY,oBAAI,IAAsB;AAC5C,UAAM,eAAe,oBAAI,IAAsB;AAE/C,aAAS,UAAU,MAAuB;AACtC,aAAO,KAAK,UAAU,MAAM,SAAyC,KAAK,OAAO;AAG7E,cAAM,MAAM,KAAK,GAAG;AACpB,YAAI,eAAe,OAAO;AACtB,iBAAO,aAAa,GAAG;AAAA,QAC3B;AACA,cAAM,QAAQ,WAAW,GAAG;AAC5B,YAAI,OAAO;AACP,cAAI,MAAM,IAAI,UAAU,OAAO,MAAM,KAAK,WAAW,UAAU;AAC3D,kBAAM,IAAI;AAAA,cACN;AAAA,YACJ;AAAA,UACJ;AAGA,iBAAO,EAAE,MAAM,UAAU,MAAM,CAAC,MAAM,KAAK,MAAM,EAAE;AAAA,QACvD;AACA,YAAI,OAAO,QAAQ,YAAY;AAC3B,cAAI,KAAK,aAAa,IAAI,GAAe;AACzC,cAAI,OAAO,QAAW;AAClB,iBAAK,EAAE;AACP,yBAAa,IAAI,KAAiB,EAAE;AACpC,sBAAU,IAAI,IAAI,GAAe;AAAA,UACrC;AACA,iBAAO,EAAE,MAAM,YAAY,MAAM,CAAC,IAAI,IAAI,MAAM,EAAE;AAAA,QACtD;AACA,eAAO;AAAA,MACX,CAAC;AAAA,IACL;AAEA,aAAS,YAAY,MAAuB;AACxC,aAAO,KAAK,MAAM,MAAM,CAAC,MAAM,UAAU;AACrC,YAAI,iBAAiB,KAAK,GAAG;AAGzB,iBAAO,WAAW,EAAE,QAAQ,MAAM,KAAK,CAAC,EAAE,CAAC;AAAA,QAC/C;AACA,YAAI,gBAAgB,KAAK,GAAG;AACxB,iBAAO,aAAa,KAAK;AAAA,QAC7B;AACA,eAAO;AAAA,MACX,CAAC;AAAA,IACL;AAEA,aAAS,KAAK,MAAqB;AAC/B,cAAQ,YAAY,UAAU,IAAI,CAAC;AAAA,IACvC;AAEA,mBAAe,aAAa,MAA8B;AACtD,YAAM,KAAK,UAAU,IAAI,KAAK,QAAkB;AAChD,UAAI,CAAC,MAAM,OAAO,KAAK,SAAS,UAAU;AACtC;AAAA,MACJ;AACA,UAAI;AACA,aAAK,EAAE,MAAM,KAAK,MAAM,QAAQ,MAAM,GAAG,GAAI,KAAK,QAAQ,CAAC,CAAE,EAAE,CAAC;AAAA,MACpE,SAAS,OAAO;AACZ,aAAK,EAAE,MAAM,KAAK,MAAM,MAAM,CAAC;AAAA,MACnC;AAAA,IACJ;AAEA,UAAM,WAA4B,WAAS;AACvC,UAAI;AACJ,UAAI;AACA,eAAO,YAAY,MAAM,IAAI;AAAA,MACjC,QAAQ;AACJ;AAAA,MACJ;AACA,UAAI,OAAO,KAAK,aAAa,UAAU;AACnC,aAAK,aAAa,IAAI;AACtB;AAAA,MACJ;AACA,UAAI,OAAO,KAAK,OAAO,UAAU;AAC7B;AAAA,MACJ;AACA,YAAM,QAAQ,QAAQ,IAAI,KAAK,EAAE;AACjC,UAAI,CAAC,OAAO;AACR;AAAA,MACJ;AACA,cAAQ,OAAO,KAAK,EAAE;AACtB,UAAI,KAAK,OAAO;AACZ,cAAM,OAAO,KAAK,KAAK;AAAA,MAC3B,OAAO;AACH,cAAM,QAAQ,KAAK,MAAM;AAAA,MAC7B;AAAA,IACJ;AAEA,YAAQ,iBAAiB,WAAW,QAAQ;AAE5C,aAAS,KAAK,MAAY,KAA6B;AACnD,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACpC,cAAM,KAAK,EAAE;AACb,YAAI;AACJ,YAAI;AACA,oBAAU,UAAU,EAAE,IAAI,GAAG,MAAM,IAAI,CAAC;AAAA,QAC5C,SAAS,OAAO;AAGZ,iBAAO,KAAK;AACZ;AAAA,QACJ;AACA,gBAAQ,IAAI,IAAI,EAAE,SAAS,OAAO,CAAC;AACnC,gBAAQ,YAAY,OAAO;AAAA,MAC/B,CAAC;AAAA,IACL;AAMA,aAAS,WAAW,MAAY,MAAY,CAAC,GAAW;AACpD,YAAM,SAAS,WAAY;AAAA,MAAC;AAC5B,aAAO,IAAI,MAAM,QAAQ;AAAA,QACrB,MAAM,SAAS,WAAW,MAAiB;AACvC,iBAAO,WAAW,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,QAAQ,KAAK,CAAC,CAAC;AAAA,QAC5D;AAAA,QACA,IAAI,SAAS,KAAK;AACd,cAAI,QAAQ,QAAQ;AAChB,mBAAO,EAAE,MAAM,IAAI;AAAA,UACvB;AACA,cAAI,QAAQ,QAAQ;AAMhB,gBAAI,CAAC,IAAI,QAAQ;AACb,qBAAO;AAAA,YACX;AACA,mBAAO,CACH,SACA,WACC,KAAK,MAAM,GAAG,EAAE,KAAK,SAAS,MAAM;AAAA,UAC7C;AACA,cAAI,OAAO,QAAQ,UAAU;AACzB,mBAAO;AAAA,UACX;AACA,iBAAO,WAAW,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,OAAO,IAAI,CAAC,CAAC;AAAA,QAC1D;AAAA,MACJ,CAAC;AAAA,IACL;AAIA,aAAS,UAAU,QAAyB;AACxC,YAAM,QAAQ,WAAW,MAAM;AAC/B,UAAI,CAAC,SAAS,MAAM,IAAI,UAAU,OAAO,MAAM,KAAK,WAAW,UAAU;AACrE,cAAM,IAAI,UAAU,iCAAiC;AAAA,MACzD;AACA,aAAO,MAAM,KAAK;AAAA,IACtB;AAEA,WAAO;AAAA,MACH,QAAQ,MAAsB;AAC1B,eAAO,WAAW,EAAE,WAAW,KAAK,CAAC;AAAA,MACzC;AAAA,MACA,OAAO,QAAyB;AAC5B,eAAO,UAAU,MAAM;AAAA,MAC3B;AAAA,MACA,QAAQ,QAAuB;AAC3B,aAAK,EAAE,SAAS,OAAO,WAAW,WAAW,SAAS,UAAU,MAAM,EAAE,CAAC;AAAA,MAC7E;AAAA,MACA,QAAc;AACV,gBAAQ,oBAAoB,WAAW,QAAQ;AAC/C,gBAAQ,MAAM;AACd,kBAAU,MAAM;AAChB,qBAAa,MAAM;AAAA,MACvB;AAAA,IACJ;AAAA,EACJ;","names":[]}