@adobe/uix-core 0.6.5 → 0.7.1-nightly.20230114

package/dist/index.js

@@ -1,5 +1,208 @@
 'use strict';
 
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/eventemitter3/index.js"(exports, module) {
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events();
+      else
+        delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1); j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
 // src/debuglog.ts
 var isDarkMode = () => typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
 var Layouts = {
@@ -242,25 +445,721 @@ function makeNamespaceProxy(invoke, path = []) {
   });
 }
 
-// src/timeout-promise.ts
-function timeoutPromise(timeoutMs, promise) {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(
-      () => reject(new Error(`Timed out after ${timeoutMs}ms`)),
-      timeoutMs
+// src/constants.ts
+var NS_ROOT = "_$pg";
+var VERSION = "0.7.0";
+var INIT_CALLBACK = `${NS_ROOT}_init_cb`;
+
+// src/value-assertions.ts
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Reflect.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function isPrimitive(value) {
+  if (!value) {
+    return true;
+  }
+  const theType = typeof value;
+  return theType === "string" || theType === "number" || theType === "boolean";
+}
+function isIterable(value) {
+  return Array.isArray(value);
+}
+function hasProp(value, prop) {
+  return !isPrimitive(value) && Reflect.has(value, prop);
+}
+function isIframe(value) {
+  if (!value || isPrimitive(value)) {
+    return false;
+  }
+  const { nodeName } = value;
+  return typeof nodeName === "string" && nodeName.toLowerCase() === "iframe";
+}
+function isObjectWithPrototype(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Reflect.getPrototypeOf(value);
+  return proto !== Object.prototype;
+}
+
+// src/message-wrapper.ts
+function wrap(message) {
+  return { [NS_ROOT]: message };
+}
+function unwrap(wrappedMessage) {
+  return wrappedMessage[NS_ROOT];
+}
+function isWrapped(item) {
+  if (!isPlainObject(item)) {
+    return false;
+  }
+  const keys = Object.keys(item);
+  const hasRoot = keys.includes(NS_ROOT);
+  if (hasRoot && keys.length != 1) {
+    console.error(
+      `malformed tunnel message, should have one prop "${NS_ROOT}" at root`,
+      item
+    );
+    return false;
+  }
+  return hasRoot;
+}
+
+// src/object-walker.ts
+var NOT_TRANSFORMED = Symbol.for("NOT_TRANSFORMED");
+var CIRCULAR = "[[Circular]]";
+function transformRecursive(transform, value, parent, _refs = /* @__PURE__ */ new WeakSet()) {
+  if (isPrimitive(value)) {
+    return value;
+  }
+  const transformed = transform(value, parent);
+  if (transformed !== NOT_TRANSFORMED) {
+    return transformed;
+  }
+  if (isIterable(value)) {
+    const outArray = [];
+    for (const item of value) {
+      outArray.push(transformRecursive(transform, item, void 0, _refs));
+    }
+    return outArray;
+  }
+  if (isPlainObject(value)) {
+    if (_refs.has(value)) {
+      return CIRCULAR;
+    }
+    _refs.add(value);
+    const outObj = {};
+    for (const key of Reflect.ownKeys(value)) {
+      Reflect.set(
+        outObj,
+        key,
+        transformRecursive(transform, Reflect.get(value, key), void 0, _refs)
+      );
+    }
+    return outObj;
+  }
+  if (isObjectWithPrototype(value)) {
+    if (_refs.has(value)) {
+      return CIRCULAR;
+    }
+    _refs.add(value);
+    const getObjectKeys = (obj) => {
+      const result = /* @__PURE__ */ new Set();
+      do {
+        if (Reflect.getPrototypeOf(obj) !== null) {
+          for (const prop of Object.getOwnPropertyNames(obj)) {
+            if (prop === "constructor") {
+              continue;
+            }
+            result.add(prop);
+          }
+        }
+      } while (obj = Reflect.getPrototypeOf(obj));
+      return [...result];
+    };
+    const outObj = {};
+    const properties = getObjectKeys(value);
+    for (const key of properties) {
+      Reflect.set(
+        outObj,
+        key,
+        transformRecursive(transform, Reflect.get(value, key), value, _refs)
+      );
+    }
+    return outObj;
+  }
+  throw new Error(`Bad value! ${Object.prototype.toString.call(value)}`);
+}
+
+// src/rpc/call-receiver.ts
+function receiveCalls(fn, ticket, remote) {
+  const responder = async ({ fnId, callId, args }) => {
+    try {
+      const value = await fn(...args);
+      remote.deref().respond({
+        fnId,
+        callId,
+        value,
+        status: "resolve"
+      });
+    } catch (error) {
+      remote.deref().respond({
+        fnId,
+        callId,
+        status: "reject",
+        error
+      });
+    }
+  };
+  return remote.deref().onCall(ticket, responder);
+}
+
+// src/rpc/call-sender.ts
+var DisconnectionError = class extends Error {
+  constructor() {
+    super(
+      "Function belongs to a simulated remote object which has been disconnected! The tunnel may have been destroyed by page navigation or reload."
+    );
+  }
+};
+function dispatch(subject, callTicket, rejectionPool, resolve, reject) {
+  subject.onRespond(callTicket, (responseTicket) => {
+    rejectionPool.delete(reject);
+    if (responseTicket.status === "resolve") {
+      resolve(responseTicket.value);
+    } else {
+      reject(responseTicket.error);
+    }
+  });
+  subject.send(callTicket);
+}
+function makeCallSender({ fnId }, subjectRef) {
+  let callCounter = 0;
+  const rejectionPool = /* @__PURE__ */ new Set();
+  let sender = function(...args) {
+    return new Promise((resolve, reject) => {
+      rejectionPool.add(reject);
+      const callId = ++callCounter;
+      const callTicket = {
+        fnId,
+        callId,
+        args
+      };
+      return dispatch(
+        subjectRef.deref(),
+        callTicket,
+        rejectionPool,
+        resolve,
+        reject
+      );
+    });
+  };
+  const destroy = () => {
+    subjectRef = null;
+    sender = () => {
+      throw new DisconnectionError();
+    };
+    for (const reject of rejectionPool) {
+      reject(new DisconnectionError());
+    }
+    rejectionPool.clear();
+  };
+  subjectRef.deref().onDestroyed(destroy);
+  const facade = async function(...args) {
+    return sender(...args);
+  };
+  Object.defineProperty(facade, "name", { value: fnId });
+  return facade;
+}
+
+// src/remote-subject.ts
+var RemoteSubject = class {
+  constructor(emitter, simulator) {
+    this.emitter = emitter;
+    this.simulator = simulator;
+  }
+  notifyCleanup(ticket) {
+    return this.emitter.emit(`${ticket.fnId}_g`, {});
+  }
+  notifyConnect() {
+    return this.emitter.emit("connected");
+  }
+  notifyDestroy() {
+    return this.emitter.emit("destroyed");
+  }
+  onCall(ticket, handler) {
+    return this.subscribe(
+      `${ticket.fnId}_c`,
+      (ticket2) => handler(this.processCallTicket(ticket2, this.simulator.materialize))
+    );
+  }
+  onConnected(handler) {
+    return this.subscribe("connected", handler);
+  }
+  onDestroyed(handler) {
+    return this.subscribe("destroyed", handler);
+  }
+  onOutOfScope(ticket, handler) {
+    return this.subscribeOnce(`${ticket.fnId}_g`, handler);
+  }
+  onRespond(ticket, handler) {
+    const fnAndCall = `${ticket.fnId}${ticket.callId}`;
+    return this.subscribeOnce(
+      `${fnAndCall}_r`,
+      (ticket2) => handler(this.processResponseTicket(ticket2, this.simulator.materialize))
+    );
+  }
+  respond(ticket) {
+    const fnAndCall = `${ticket.fnId}${ticket.callId}`;
+    return this.emitter.emit(
+      `${fnAndCall}_r`,
+      this.processResponseTicket(ticket, this.simulator.simulate)
+    );
+  }
+  send(ticket) {
+    return this.emitter.emit(
+      `${ticket.fnId}_c`,
+      this.processCallTicket(ticket, this.simulator.simulate)
     );
+  }
+  processCallTicket({ args, ...ticket }, mapper) {
+    return {
+      ...ticket,
+      args: args.map(mapper)
+    };
+  }
+  processResponseTicket(ticket, mapper) {
+    return ticket.status === "resolve" ? { ...ticket, value: mapper(ticket.value) } : ticket;
+  }
+  subscribe(type, handler) {
+    this.emitter.on(type, handler);
+    return () => {
+      this.emitter.off(type, handler);
+    };
+  }
+  subscribeOnce(type, handler) {
+    const once = (arg) => {
+      this.emitter.off(type, once);
+      handler(arg);
+    };
+    return this.subscribe(type, once);
+  }
+};
+
+// src/object-simulator.ts
+function isDefMessage(value) {
+  return isWrapped(value) && hasProp(unwrap(value), "fnId");
+}
+var bindAll = (inst, methods) => {
+  for (const methodName of methods) {
+    const method = inst[methodName];
+    if (typeof method === "function") {
+      inst[methodName] = method.bind(inst);
+    }
+  }
+};
+var ObjectSimulator = class {
+  constructor(subject, cleanupNotifier) {
+    this.fnCounter = 0;
+    this.receiverTicketCache = /* @__PURE__ */ new WeakMap();
+    this.senderCache = /* @__PURE__ */ new WeakMap();
+    this.cleanupNotifier = cleanupNotifier;
+    this.subject = subject;
+    bindAll(this, ["makeSender", "makeReceiver", "simulate", "materialize"]);
+  }
+  static create(emitter, Cleanup) {
+    let simulator;
+    const simulatorInterface = {
+      simulate: (x) => simulator.simulate(x),
+      materialize: (x) => simulator.materialize(x)
+    };
+    const subject = new RemoteSubject(emitter, simulatorInterface);
+    const cleanupNotifier = new Cleanup((fnId) => {
+      return subject.notifyCleanup({ fnId });
+    });
+    simulator = new ObjectSimulator(subject, cleanupNotifier);
+    return simulator;
+  }
+  makeReceiver(fn, parent) {
+    if (typeof fn !== "function") {
+      return NOT_TRANSFORMED;
+    }
+    let fnTicket = this.receiverTicketCache.get(fn);
+    if (!fnTicket) {
+      fnTicket = {
+        fnId: `${fn.name || "<anonymous>"}_${++this.fnCounter}`
+      };
+      let boundFunction = fn;
+      if (parent) {
+        boundFunction = fn.bind(parent);
+      }
+      const cleanup = receiveCalls(
+        boundFunction,
+        fnTicket,
+        new WeakRef(this.subject)
+      );
+      this.subject.onOutOfScope(fnTicket, cleanup);
+      this.receiverTicketCache.set(boundFunction, fnTicket);
+    }
+    return wrap(fnTicket);
+  }
+  makeSender(message) {
+    if (!isDefMessage(message)) {
+      return NOT_TRANSFORMED;
+    }
+    const ticket = unwrap(message);
+    if (!this.senderCache.has(ticket)) {
+      const sender = makeCallSender(ticket, new WeakRef(this.subject));
+      this.cleanupNotifier.register(sender, ticket.fnId, sender);
+      this.senderCache.set(ticket, sender);
+      return sender;
+    } else {
+      return this.senderCache.get(ticket);
+    }
+  }
+  materialize(simulated) {
+    return transformRecursive(
+      this.makeSender,
+      simulated
+    );
+  }
+  simulate(localObject) {
+    return transformRecursive(
+      this.makeReceiver,
+      localObject
+    );
+  }
+};
+
+// src/promises/timed.ts
+function timeoutPromise(description, promise, ms, onReject) {
+  return new Promise((resolve, reject) => {
+    const cleanupAndReject = async (e) => {
+      try {
+        await onReject(e);
+      } finally {
+        reject(e);
+      }
+    };
+    const timeout = setTimeout(() => {
+      cleanupAndReject(new Error(`${description} timed out after ${ms}ms`));
+    }, ms);
     promise.then((result) => {
       clearTimeout(timeout);
       resolve(result);
-    }).catch(reject);
+    }).catch((e) => {
+      clearTimeout(timeout);
+      cleanupAndReject(e);
+    });
+  });
+}
+
+// src/tickets.ts
+var INIT_TICKET = {
+  fnId: INIT_CALLBACK
+};
+
+// src/tunnel/tunnel.ts
+var import_eventemitter3 = __toESM(require_eventemitter3());
+
+// src/tunnel/tunnel-messenger.ts
+var TunnelMessenger = class {
+  constructor(opts) {
+    this.versionWarnings = /* @__PURE__ */ new Set();
+    this.myOrigin = opts.myOrigin;
+    this.remoteOrigin = opts.targetOrigin === "*" ? "remote document" : opts.targetOrigin;
+    this.logger = opts.logger;
+  }
+  resetWarnings() {
+    this.versionWarnings.clear();
+  }
+  makeAccepted(id) {
+    return wrap({
+      accepts: id,
+      version: VERSION
+    });
+  }
+  makeOffered(id) {
+    return wrap({
+      offers: id,
+      version: VERSION
+    });
+  }
+  isHandshakeAccepting(message, id) {
+    return this.isHandshake(message) && unwrap(message).accepts === id;
+  }
+  isHandshakeOffer(message) {
+    return this.isHandshake(message) && typeof unwrap(message).offers === "string";
+  }
+  isHandshake(message) {
+    if (!isWrapped(message)) {
+      this.logMalformed(message);
+      return false;
+    }
+    const tunnelData = unwrap(
+      message
+    );
+    if (!isPlainObject(tunnelData) || typeof tunnelData.version !== "string" || !(Reflect.has(tunnelData, "accepts") || Reflect.has(tunnelData, "offers"))) {
+      this.logMalformed(message);
+      return false;
+    }
+    const { version } = tunnelData;
+    if (version !== VERSION && !this.versionWarnings.has(version)) {
+      this.versionWarnings.add(version);
+      this.logger.warn(
+        `SDK version mismatch. ${this.myOrigin} is using v${VERSION}, but received message from ${this.remoteOrigin} using SDK v${version}. Extensions may be broken or unresponsive.`
+      );
+    }
+    return true;
+  }
+  logMalformed(message) {
+    let inspectedMessage;
+    try {
+      inspectedMessage = JSON.stringify(message, null, 2);
+    } catch (_) {
+      try {
+        inspectedMessage = message.toString();
+      } catch (e) {
+        inspectedMessage = Object.prototype.toString.call(message);
+      }
+    }
+    this.logger.error(
+      `Malformed tunnel message sent from SDK at ${this.remoteOrigin} to ${this.myOrigin}:
+${inspectedMessage}
+Message must be an object with "${NS_ROOT}" property, which must be an object with a "version" string and an either an "accepts" or "offers" property containing an ID string.`
+    );
+  }
+};
+
+// src/tunnel/tunnel.ts
+var RETRY_MS = 100;
+var STATUSCHECK_MS = 5e3;
+var KEY_BASE = 36;
+var KEY_LENGTH = 8;
+var KEY_EXP = KEY_BASE ** KEY_LENGTH;
+var makeKey = () => Math.round(Math.random() * KEY_EXP).toString(KEY_BASE);
+var badTimeout = "\n - timeout value must be a number of milliseconds";
+var badTargetOrigin = "\n - targetOrigin must be a valid URL origin or '*' for any origin";
+function isFromOrigin(event, source, targetOrigin) {
+  try {
+    return source === event.source && (targetOrigin === "*" || targetOrigin === new URL(event.origin).origin);
+  } catch (_) {
+    return false;
+  }
+}
+var { emit: emitOn } = import_eventemitter3.default.prototype;
+var Tunnel = class extends import_eventemitter3.default {
+  constructor(config) {
+    super();
+    this.emitLocal = (type, payload) => {
+      return emitOn.call(this, type, payload);
+    };
+    this._emitFromMessage = ({ data: { type, payload } }) => {
+      this.emitLocal(type, payload);
+    };
+    this.config = config;
+  }
+  static toIframe(target, options) {
+    if (!isIframe(target)) {
+      throw new Error(
+        `Provided tunnel target is not an iframe! ${Object.prototype.toString.call(
+          target
+        )}`
+      );
+    }
+    const source = target.contentWindow;
+    const config = Tunnel._normalizeConfig(options);
+    const tunnel = new Tunnel(config);
+    const messenger = new TunnelMessenger({
+      myOrigin: window.location.origin,
+      targetOrigin: options.targetOrigin,
+      logger: options.logger || console
+    });
+    let frameStatusCheck;
+    let timeout;
+    const offerListener = (event) => {
+      if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeOffer(event.data)) {
+        const accepted = messenger.makeAccepted(unwrap(event.data).offers);
+        const channel = new MessageChannel();
+        source.postMessage(accepted, config.targetOrigin, [channel.port1]);
+        tunnel.connect(channel.port2);
+      }
+    };
+    const cleanup = () => {
+      clearTimeout(timeout);
+      clearInterval(frameStatusCheck);
+      window.removeEventListener("message", offerListener);
+    };
+    timeout = window.setTimeout(() => {
+      tunnel.emitLocal(
+        "error",
+        new Error(
+          `Timed out awaiting initial message from iframe after ${config.timeout}ms`
+        )
+      );
+      tunnel.destroy();
+    }, config.timeout);
+    tunnel.on("destroyed", cleanup);
+    tunnel.on("connected", () => clearTimeout(timeout));
+    frameStatusCheck = window.setInterval(() => {
+      if (!target.isConnected) {
+        tunnel.destroy();
+      }
+    }, STATUSCHECK_MS);
+    window.addEventListener("message", offerListener);
+    return tunnel;
+  }
+  static toParent(source, opts) {
+    let retrying;
+    let timeout;
+    const key = makeKey();
+    const config = Tunnel._normalizeConfig(opts);
+    const tunnel = new Tunnel(config);
+    const messenger = new TunnelMessenger({
+      myOrigin: window.location.origin,
+      targetOrigin: config.targetOrigin,
+      logger: config.logger
+    });
+    const acceptListener = (event) => {
+      if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeAccepting(event.data, key)) {
+        cleanup();
+        if (!event.ports || !event.ports.length) {
+          const portError = new Error(
+            "Received handshake accept message, but it did not include a MessagePort to establish tunnel"
+          );
+          tunnel.emitLocal("error", portError);
+          return;
+        }
+        tunnel.connect(event.ports[0]);
+      }
+    };
+    const cleanup = () => {
+      clearInterval(retrying);
+      clearTimeout(timeout);
+      window.removeEventListener("message", acceptListener);
+    };
+    timeout = window.setTimeout(() => {
+      tunnel.emitLocal(
+        "error",
+        new Error(
+          `Timed out waiting for initial response from parent after ${config.timeout}ms`
+        )
+      );
+      tunnel.destroy();
+    }, config.timeout);
+    window.addEventListener("message", acceptListener);
+    tunnel.on("destroyed", cleanup);
+    tunnel.on("connected", cleanup);
+    const sendOffer = () => source.postMessage(messenger.makeOffered(key), config.targetOrigin);
+    retrying = window.setInterval(sendOffer, RETRY_MS);
+    sendOffer();
+    return tunnel;
+  }
+  connect(remote) {
+    if (this._messagePort) {
+      this._messagePort.removeEventListener("message", this._emitFromMessage);
+      this._messagePort.close();
+    }
+    this._messagePort = remote;
+    remote.addEventListener("message", this._emitFromMessage);
+    this.emit("connected");
+    this._messagePort.start();
+  }
+  destroy() {
+    if (this._messagePort) {
+      this._messagePort.close();
+      this._messagePort = null;
+    }
+    this.emitLocal("destroyed");
+    this.emit("destroyed");
+  }
+  emit(type, payload) {
+    if (!this._messagePort) {
+      return false;
+    }
+    this._messagePort.postMessage({ type, payload });
+    return true;
+  }
+  static _normalizeConfig(options = {}) {
+    let errorMessage = "";
+    const config = {
+      timeout: 4e3,
+      logger: console,
+      ...options
+    };
+    const timeoutMs = Number(config.timeout);
+    if (!Number.isSafeInteger(timeoutMs)) {
+      errorMessage += badTimeout;
+    }
+    if (config.targetOrigin !== "*") {
+      try {
+        new URL(config.targetOrigin);
+      } catch (e) {
+        errorMessage += badTargetOrigin;
+      }
+    }
+    if (errorMessage) {
+      throw new Error(`Invalid tunnel configuration: ${errorMessage}`);
+    }
+    return config;
+  }
+};
+
+// src/cross-realm-object.ts
+var INIT_MESSAGE = wrap(INIT_TICKET);
+async function setupApiExchange(tunnel, apiToSend) {
+  let done = false;
+  let remoteApi;
+  const xrObject = {
+    tunnel,
+    getRemoteApi() {
+      return remoteApi;
+    }
+  };
+  return timeoutPromise(
+    "Initial API exchange",
+    new Promise((resolve, reject) => {
+      const simulator = ObjectSimulator.create(tunnel, FinalizationRegistry);
+      const sendApi = simulator.makeSender(INIT_MESSAGE);
+      const apiCallback = (api) => {
+        remoteApi = api;
+        if (!done) {
+          done = true;
+          resolve(xrObject);
+        }
+      };
+      tunnel.on("api", apiCallback);
+      const unsubscribe = receiveCalls(
+        (api) => tunnel.emitLocal("api", api),
+        INIT_TICKET,
+        new WeakRef(simulator.subject)
+      );
+      const destroy = (e) => {
+        unsubscribe();
+        if (!done) {
+          done = true;
+          reject(e);
+        }
+      };
+      tunnel.on("destroyed", destroy);
+      tunnel.on(
+        "connected",
+        () => sendApi(apiToSend).catch(destroy)
+      );
+    }),
+    tunnel.config.timeout,
+    () => tunnel.destroy()
+  );
+}
+async function connectParentWindow(tunnelOptions, apiToSend) {
+  const tunnel = Tunnel.toParent(window.parent, tunnelOptions);
+  return setupApiExchange(tunnel, apiToSend);
+}
+async function connectIframe(frame, tunnelOptions, apiToSend) {
+  const tunnel = Tunnel.toIframe(frame, tunnelOptions);
+  return setupApiExchange(tunnel, apiToSend);
+}
+
+// src/promises/wait.ts
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
   });
 }
 
 exports.Emitter = Emitter;
+exports.Tunnel = Tunnel;
 exports._customConsole = _customConsole;
+exports.connectIframe = connectIframe;
+exports.connectParentWindow = connectParentWindow;
 exports.debugEmitter = debugEmitter;
 exports.makeNamespaceProxy = makeNamespaceProxy;
 exports.quietConsole = quietConsole;
 exports.timeoutPromise = timeoutPromise;
+exports.wait = wait;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map