@adobe/uix-guest 0.6.3

package/dist/iife/index.js

@@ -0,0 +1,761 @@
+var AdobeUIXGuest = (() => {
+  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 src_exports = {};
+  __export(src_exports, {
+    GuestServer: () => GuestServer,
+    GuestUI: () => GuestUI,
+    PrimaryGuest: () => GuestServer,
+    UIGuest: () => GuestUI,
+    attach: () => attach,
+    createGuest: () => createGuest,
+    register: () => register
+  });
+
+  // ../../node_modules/penpal/lib/enums.js
+  var MessageType;
+  (function(MessageType2) {
+    MessageType2["Call"] = "call";
+    MessageType2["Reply"] = "reply";
+    MessageType2["Syn"] = "syn";
+    MessageType2["SynAck"] = "synAck";
+    MessageType2["Ack"] = "ack";
+  })(MessageType || (MessageType = {}));
+  var Resolution;
+  (function(Resolution2) {
+    Resolution2["Fulfilled"] = "fulfilled";
+    Resolution2["Rejected"] = "rejected";
+  })(Resolution || (Resolution = {}));
+  var ErrorCode;
+  (function(ErrorCode2) {
+    ErrorCode2["ConnectionDestroyed"] = "ConnectionDestroyed";
+    ErrorCode2["ConnectionTimeout"] = "ConnectionTimeout";
+    ErrorCode2["NoIframeSrc"] = "NoIframeSrc";
+  })(ErrorCode || (ErrorCode = {}));
+  var NativeErrorName;
+  (function(NativeErrorName2) {
+    NativeErrorName2["DataCloneError"] = "DataCloneError";
+  })(NativeErrorName || (NativeErrorName = {}));
+  var NativeEventType;
+  (function(NativeEventType2) {
+    NativeEventType2["Message"] = "message";
+  })(NativeEventType || (NativeEventType = {}));
+
+  // ../../node_modules/penpal/lib/createDestructor.js
+  var createDestructor_default = (localName, log) => {
+    const callbacks = [];
+    let destroyed = false;
+    return {
+      destroy(error) {
+        if (!destroyed) {
+          destroyed = true;
+          log(`${localName}: Destroying connection`);
+          callbacks.forEach((callback) => {
+            callback(error);
+          });
+        }
+      },
+      onDestroy(callback) {
+        destroyed ? callback() : callbacks.push(callback);
+      }
+    };
+  };
+
+  // ../../node_modules/penpal/lib/createLogger.js
+  var createLogger_default = (debug) => {
+    return (...args) => {
+      if (debug) {
+        console.log("[Penpal]", ...args);
+      }
+    };
+  };
+
+  // ../../node_modules/penpal/lib/errorSerialization.js
+  var serializeError = ({ name, message, stack }) => ({
+    name,
+    message,
+    stack
+  });
+  var deserializeError = (obj) => {
+    const deserializedError = new Error();
+    Object.keys(obj).forEach((key) => deserializedError[key] = obj[key]);
+    return deserializedError;
+  };
+
+  // ../../node_modules/penpal/lib/connectCallReceiver.js
+  var connectCallReceiver_default = (info, serializedMethods, log) => {
+    const { localName, local, remote, originForSending, originForReceiving } = info;
+    let destroyed = false;
+    const handleMessageEvent = (event) => {
+      if (event.source !== remote || event.data.penpal !== MessageType.Call) {
+        return;
+      }
+      if (originForReceiving !== "*" && event.origin !== originForReceiving) {
+        log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
+        return;
+      }
+      const callMessage = event.data;
+      const { methodName, args, id: id2 } = callMessage;
+      log(`${localName}: Received ${methodName}() call`);
+      const createPromiseHandler = (resolution) => {
+        return (returnValue) => {
+          log(`${localName}: Sending ${methodName}() reply`);
+          if (destroyed) {
+            log(`${localName}: Unable to send ${methodName}() reply due to destroyed connection`);
+            return;
+          }
+          const message = {
+            penpal: MessageType.Reply,
+            id: id2,
+            resolution,
+            returnValue
+          };
+          if (resolution === Resolution.Rejected && returnValue instanceof Error) {
+            message.returnValue = serializeError(returnValue);
+            message.returnValueIsError = true;
+          }
+          try {
+            remote.postMessage(message, originForSending);
+          } catch (err) {
+            if (err.name === NativeErrorName.DataCloneError) {
+              const errorReplyMessage = {
+                penpal: MessageType.Reply,
+                id: id2,
+                resolution: Resolution.Rejected,
+                returnValue: serializeError(err),
+                returnValueIsError: true
+              };
+              remote.postMessage(errorReplyMessage, originForSending);
+            }
+            throw err;
+          }
+        };
+      };
+      new Promise((resolve) => resolve(serializedMethods[methodName].apply(serializedMethods, args))).then(createPromiseHandler(Resolution.Fulfilled), createPromiseHandler(Resolution.Rejected));
+    };
+    local.addEventListener(NativeEventType.Message, handleMessageEvent);
+    return () => {
+      destroyed = true;
+      local.removeEventListener(NativeEventType.Message, handleMessageEvent);
+    };
+  };
+
+  // ../../node_modules/penpal/lib/generateId.js
+  var id = 0;
+  var generateId_default = () => ++id;
+
+  // ../../node_modules/penpal/lib/methodSerialization.js
+  var KEY_PATH_DELIMITER = ".";
+  var keyPathToSegments = (keyPath) => keyPath ? keyPath.split(KEY_PATH_DELIMITER) : [];
+  var segmentsToKeyPath = (segments) => segments.join(KEY_PATH_DELIMITER);
+  var createKeyPath = (key, prefix) => {
+    const segments = keyPathToSegments(prefix || "");
+    segments.push(key);
+    return segmentsToKeyPath(segments);
+  };
+  var setAtKeyPath = (subject, keyPath, value) => {
+    const segments = keyPathToSegments(keyPath);
+    segments.reduce((prevSubject, key, idx) => {
+      if (typeof prevSubject[key] === "undefined") {
+        prevSubject[key] = {};
+      }
+      if (idx === segments.length - 1) {
+        prevSubject[key] = value;
+      }
+      return prevSubject[key];
+    }, subject);
+    return subject;
+  };
+  var serializeMethods = (methods, prefix) => {
+    const flattenedMethods = {};
+    Object.keys(methods).forEach((key) => {
+      const value = methods[key];
+      const keyPath = createKeyPath(key, prefix);
+      if (typeof value === "object") {
+        Object.assign(flattenedMethods, serializeMethods(value, keyPath));
+      }
+      if (typeof value === "function") {
+        flattenedMethods[keyPath] = value;
+      }
+    });
+    return flattenedMethods;
+  };
+  var deserializeMethods = (flattenedMethods) => {
+    const methods = {};
+    for (const keyPath in flattenedMethods) {
+      setAtKeyPath(methods, keyPath, flattenedMethods[keyPath]);
+    }
+    return methods;
+  };
+
+  // ../../node_modules/penpal/lib/connectCallSender.js
+  var connectCallSender_default = (callSender, info, methodKeyPaths, destroyConnection, log) => {
+    const { localName, local, remote, originForSending, originForReceiving } = info;
+    let destroyed = false;
+    log(`${localName}: Connecting call sender`);
+    const createMethodProxy = (methodName) => {
+      return (...args) => {
+        log(`${localName}: Sending ${methodName}() call`);
+        let iframeRemoved;
+        try {
+          if (remote.closed) {
+            iframeRemoved = true;
+          }
+        } catch (e) {
+          iframeRemoved = true;
+        }
+        if (iframeRemoved) {
+          destroyConnection();
+        }
+        if (destroyed) {
+          const error = new Error(`Unable to send ${methodName}() call due to destroyed connection`);
+          error.code = ErrorCode.ConnectionDestroyed;
+          throw error;
+        }
+        return new Promise((resolve, reject) => {
+          const id2 = generateId_default();
+          const handleMessageEvent = (event) => {
+            if (event.source !== remote || event.data.penpal !== MessageType.Reply || event.data.id !== id2) {
+              return;
+            }
+            if (originForReceiving !== "*" && event.origin !== originForReceiving) {
+              log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
+              return;
+            }
+            const replyMessage = event.data;
+            log(`${localName}: Received ${methodName}() reply`);
+            local.removeEventListener(NativeEventType.Message, handleMessageEvent);
+            let returnValue = replyMessage.returnValue;
+            if (replyMessage.returnValueIsError) {
+              returnValue = deserializeError(returnValue);
+            }
+            (replyMessage.resolution === Resolution.Fulfilled ? resolve : reject)(returnValue);
+          };
+          local.addEventListener(NativeEventType.Message, handleMessageEvent);
+          const callMessage = {
+            penpal: MessageType.Call,
+            id: id2,
+            methodName,
+            args
+          };
+          remote.postMessage(callMessage, originForSending);
+        });
+      };
+    };
+    const flattenedMethods = methodKeyPaths.reduce((api, name) => {
+      api[name] = createMethodProxy(name);
+      return api;
+    }, {});
+    Object.assign(callSender, deserializeMethods(flattenedMethods));
+    return () => {
+      destroyed = true;
+    };
+  };
+
+  // ../../node_modules/penpal/lib/startConnectionTimeout.js
+  var startConnectionTimeout_default = (timeout, callback) => {
+    let timeoutId;
+    if (timeout !== void 0) {
+      timeoutId = window.setTimeout(() => {
+        const error = new Error(`Connection timed out after ${timeout}ms`);
+        error.code = ErrorCode.ConnectionTimeout;
+        callback(error);
+      }, timeout);
+    }
+    return () => {
+      clearTimeout(timeoutId);
+    };
+  };
+
+  // ../../node_modules/penpal/lib/child/handleSynAckMessageFactory.js
+  var handleSynAckMessageFactory_default = (parentOrigin, serializedMethods, destructor, log) => {
+    const { destroy, onDestroy } = destructor;
+    return (event) => {
+      let originQualifies = parentOrigin instanceof RegExp ? parentOrigin.test(event.origin) : parentOrigin === "*" || parentOrigin === event.origin;
+      if (!originQualifies) {
+        log(`Child: Handshake - Received SYN-ACK from origin ${event.origin} which did not match expected origin ${parentOrigin}`);
+        return;
+      }
+      log("Child: Handshake - Received SYN-ACK, responding with ACK");
+      const originForSending = event.origin === "null" ? "*" : event.origin;
+      const ackMessage = {
+        penpal: MessageType.Ack,
+        methodNames: Object.keys(serializedMethods)
+      };
+      window.parent.postMessage(ackMessage, originForSending);
+      const info = {
+        localName: "Child",
+        local: window,
+        remote: window.parent,
+        originForSending,
+        originForReceiving: event.origin
+      };
+      const destroyCallReceiver = connectCallReceiver_default(info, serializedMethods, log);
+      onDestroy(destroyCallReceiver);
+      const callSender = {};
+      const destroyCallSender = connectCallSender_default(callSender, info, event.data.methodNames, destroy, log);
+      onDestroy(destroyCallSender);
+      return callSender;
+    };
+  };
+
+  // ../../node_modules/penpal/lib/child/connectToParent.js
+  var areGlobalsAccessible = () => {
+    try {
+      clearTimeout();
+    } catch (e) {
+      return false;
+    }
+    return true;
+  };
+  var connectToParent_default = (options = {}) => {
+    const { parentOrigin = "*", methods = {}, timeout, debug = false } = options;
+    const log = createLogger_default(debug);
+    const destructor = createDestructor_default("Child", log);
+    const { destroy, onDestroy } = destructor;
+    const serializedMethods = serializeMethods(methods);
+    const handleSynAckMessage = handleSynAckMessageFactory_default(parentOrigin, serializedMethods, destructor, log);
+    const sendSynMessage = () => {
+      log("Child: Handshake - Sending SYN");
+      const synMessage = { penpal: MessageType.Syn };
+      const parentOriginForSyn = parentOrigin instanceof RegExp ? "*" : parentOrigin;
+      window.parent.postMessage(synMessage, parentOriginForSyn);
+    };
+    const promise = new Promise((resolve, reject) => {
+      const stopConnectionTimeout = startConnectionTimeout_default(timeout, destroy);
+      const handleMessage = (event) => {
+        if (!areGlobalsAccessible()) {
+          return;
+        }
+        if (event.source !== parent || !event.data) {
+          return;
+        }
+        if (event.data.penpal === MessageType.SynAck) {
+          const callSender = handleSynAckMessage(event);
+          if (callSender) {
+            window.removeEventListener(NativeEventType.Message, handleMessage);
+            stopConnectionTimeout();
+            resolve(callSender);
+          }
+        }
+      };
+      window.addEventListener(NativeEventType.Message, handleMessage);
+      sendSynMessage();
+      onDestroy((error) => {
+        window.removeEventListener(NativeEventType.Message, handleMessage);
+        if (error) {
+          reject(error);
+        }
+      });
+    });
+    return {
+      promise,
+      destroy() {
+        destroy();
+      }
+    };
+  };
+
+  // ../uix-core/dist/esm/index.js
+  var isDarkMode = () => typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
+  var Layouts = {
+    medium: {
+      padX: 5,
+      padY: 3,
+      rounded: 4,
+      fontSize: 100,
+      emphasis: "font-weight: bold;"
+    },
+    small: {
+      padX: 3,
+      padY: 1,
+      rounded: 2,
+      fontSize: 95,
+      emphasis: "font-style: italic;"
+    }
+  };
+  var Colors = {
+    yellow: {
+      text: "#333333",
+      bg: "#EBD932",
+      hilight: "#F7E434",
+      shadow: "#D1C12C"
+    },
+    green: {
+      text: "#333333",
+      bg: "#96EB5E",
+      hilight: "#9EF763",
+      shadow: "#85D154"
+    },
+    blue: {
+      text: "#333333",
+      bg: "#8DD0EB",
+      hilight: "#88F0F7",
+      shadow: "#74AED4"
+    },
+    gray: isDarkMode() ? {
+      text: "#eeeeee",
+      bg: "transparent",
+      hilight: "#cecece",
+      shadow: "#cecece"
+    } : {
+      text: "#333333",
+      bg: "#eeeeee",
+      hilight: "#f6f6f6",
+      shadow: "#cecece"
+    }
+  };
+  function memoizeUnary(fn) {
+    const cache = /* @__PURE__ */ new Map();
+    return (arg) => {
+      if (!cache.has(arg)) {
+        const result = fn(arg);
+        cache.set(arg, result);
+        if (cache.size > 100) {
+          cache.delete(cache.keys().next().value);
+        }
+        return result;
+      }
+      return cache.get(arg);
+    };
+  }
+  var toTheme = memoizeUnary((theme) => {
+    if (typeof theme === "string") {
+      const [color, size] = theme.split(" ");
+      return {
+        ...Colors[color],
+        ...Layouts[size]
+      };
+    }
+    return theme;
+  });
+  var block = `display: inline-block; border: 1px solid;`;
+  var flatten = (side) => `padding-${side}: 0px; border-${side}-width: 0px; border-top-${side}-radius: 0px; border-bottom-${side}-radius: 0px;`;
+  var toColor = ({ bg, hilight, shadow, text }) => `color: ${text}; background: ${bg}; border-color: ${hilight} ${shadow} ${shadow} ${hilight};`;
+  var toLayout = ({ fontSize, padY, padX, rounded }) => `font-size: ${fontSize}%; padding: ${padY}px ${padX}px; border-radius: ${rounded}px;`;
+  var toBubbleStyle = memoizeUnary((theme) => {
+    const base = `${block}${toColor(theme)}${toLayout(theme)}`;
+    return [
+      `${base}${flatten("right")}`,
+      `${base}${flatten("left")}${theme.emphasis}`
+    ];
+  });
+  function toBubblePrepender(bubbleLeft, bubbleRight, theme) {
+    const prefix = `%c${bubbleLeft}%c ${bubbleRight}`;
+    const [left, right] = toBubbleStyle(theme);
+    return (args) => {
+      const bubbleArgs = [prefix, left, right];
+      if (typeof args[0] === "string") {
+        bubbleArgs[0] = `${prefix}%c ${args.shift()}`;
+        bubbleArgs.push("");
+      }
+      return [...bubbleArgs, ...args];
+    };
+  }
+  var stateTypes = {
+    event: "\uFE0F\u26A1\uFE0F"
+  };
+  var stateDelim = " \u293B ";
+  var getStateFormatter = memoizeUnary((stateJson) => {
+    const stateStack = JSON.parse(stateJson);
+    const firstState = stateStack.shift();
+    const left = stateTypes[firstState.type];
+    const right = [
+      firstState.name,
+      ...stateStack.map((state) => `${stateTypes[state.type]} ${state.name}`)
+    ].join(stateDelim);
+    return toBubblePrepender(left, right, toTheme("gray small"));
+  });
+  var getStatePrepender = (stateStack) => getStateFormatter(JSON.stringify(stateStack));
+  var overrideMethods = ["log", "error", "warn", "info", "debug"];
+  var identity = (x) => x;
+  var noop = () => void 0;
+  function _customConsole(theme, type, name) {
+    const prepender = toBubblePrepender(`X${type}`, name, toTheme(theme));
+    let statePrepender = identity;
+    const stateStack = [];
+    const loggerProto = {
+      detach: {
+        writable: true,
+        configurable: true,
+        value() {
+          overrideMethods.forEach((method) => {
+            this[method] = noop;
+          });
+        }
+      },
+      pushState: {
+        value(state) {
+          stateStack.push(state);
+          statePrepender = getStatePrepender(stateStack);
+        }
+      },
+      popState: {
+        value() {
+          stateStack.pop();
+          statePrepender = stateStack.length === 0 ? identity : getStatePrepender(stateStack);
+        }
+      }
+    };
+    const customConsole = Object.create(
+      console,
+      overrideMethods.reduce((out, level) => {
+        out[level] = {
+          writable: true,
+          configurable: true,
+          value(...args) {
+            console[level](...prepender(statePrepender(args)));
+          }
+        };
+        return out;
+      }, loggerProto)
+    );
+    return customConsole;
+  }
+  var quietConsole = new Proxy(console, {
+    get() {
+      return noop;
+    }
+  });
+  function debugEmitter(emitter, opts) {
+    const logger = _customConsole(
+      opts.theme,
+      opts.type || Object.getPrototypeOf(emitter).constructor.name,
+      opts.id || emitter.id
+    );
+    const oldDispatch = emitter.dispatchEvent;
+    emitter.dispatchEvent = (event) => {
+      logger.pushState({ type: "event", name: event.type });
+      const retVal = oldDispatch.call(emitter, event);
+      logger.popState();
+      return retVal;
+    };
+    const subscriptions = [];
+    const oldDetach = logger.detach;
+    logger.detach = () => {
+      oldDetach.call(logger);
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+    };
+    function listen(type, listener) {
+      subscriptions.push(
+        emitter.addEventListener(type, (event) => listener(logger, event))
+      );
+      return logger;
+    }
+    logger.listen = listen;
+    return logger;
+  }
+  var Emitter = class extends EventTarget {
+    constructor(id2) {
+      super();
+      this.id = id2;
+    }
+    emit(type, detail) {
+      const event = new CustomEvent(type, { detail });
+      this.dispatchEvent(event);
+    }
+    addEventListener(type, listener) {
+      super.addEventListener(type, listener);
+      return () => super.removeEventListener(type, listener);
+    }
+  };
+  function makeNamespaceProxy(invoke, path = []) {
+    const handler = {
+      get: (target2, prop) => {
+        if (typeof prop === "string") {
+          if (!Reflect.has(target2, prop)) {
+            const next = makeNamespaceProxy(invoke, path.concat(prop));
+            Reflect.set(target2, prop, next);
+          }
+          return Reflect.get(target2, prop);
+        } else {
+          throw new Error(
+            `Cannot look up a symbol ${String(prop)} on a host connection proxy.`
+          );
+        }
+      }
+    };
+    const target = {};
+    if (path.length < 2) {
+      return new Proxy(target, handler);
+    }
+    const invoker = (...args) => invoke({
+      path: path.slice(0, -1),
+      name: path[path.length - 1],
+      args
+    });
+    return new Proxy(invoker, {
+      ...handler,
+      apply(target2, _, args) {
+        return target2(...args);
+      }
+    });
+  }
+  function timeoutPromise(timeoutMs, promise) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error(`Timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+      promise.then((result) => {
+        clearTimeout(timeout);
+        resolve(result);
+      }).catch(reject);
+    });
+  }
+
+  // src/debug-guest.ts
+  function debugGuest(guest) {
+    return debugEmitter(guest, {
+      theme: "yellow medium",
+      type: "Guest"
+    }).listen("beforeconnect", (log, { detail: { guest: guest2 } }) => {
+      log.info(guest2);
+    }).listen("connecting", (log, { detail: { connection } }) => {
+      log.info(connection);
+    }).listen("connected", (log, { detail: { guest: guest2 } }) => {
+      log.info(guest2);
+    }).listen("error", (log, { detail: { error, guest: guest2 } }) => {
+      log.error(
+        "\u274C Failed to connect! %s",
+        error.message,
+        guest2,
+        error
+      );
+    });
+  }
+
+  // src/guest.ts
+  var SharedContext = class {
+    constructor(values) {
+      this.reset(values);
+    }
+    reset(values) {
+      this._map = new Map(Object.entries(values));
+    }
+    get(key) {
+      return this._map.get(key);
+    }
+  };
+  var Guest2 = class extends Emitter {
+    constructor(config) {
+      super(config.id);
+      this.debugLogger = quietConsole;
+      this.host = makeNamespaceProxy(
+        async (address) => {
+          await this.hostConnectionPromise;
+          try {
+            const result = await timeoutPromise(
+              1e4,
+              this.hostConnection.invokeHostMethod(address)
+            );
+            return result;
+          } catch (e) {
+            const error = e instanceof Error ? e : new Error(e);
+            const methodError = new Error(
+              `Host method call host.${address.path.join(".")}() failed: ${error.message}`
+            );
+            this.debugLogger.error(methodError);
+            throw methodError;
+          }
+        }
+      );
+      this.timeout = 1e4;
+      if (typeof config.timeout === "number") {
+        this.timeout = config.timeout;
+      }
+      if (config.debug) {
+        this.debugLogger = debugGuest(this);
+      }
+      this.addEventListener("contextchange", (event) => {
+        this.sharedContext = new SharedContext(event.detail.context);
+      });
+    }
+    getLocalMethods() {
+      return {
+        emit: (...args) => {
+          this.debugLogger.log(`Event "${args[0]}" emitted from host`);
+          this.emit(...args);
+        }
+      };
+    }
+    async connect() {
+      return this._connect();
+    }
+    async _connect() {
+      this.emit("beforeconnect", { guest: this });
+      try {
+        const connection = connectToParent_default({
+          timeout: this.timeout,
+          methods: this.getLocalMethods()
+        });
+        this.hostConnectionPromise = connection.promise;
+        this.hostConnection = await this.hostConnectionPromise;
+        this.sharedContext = new SharedContext(
+          await this.hostConnection.getSharedContext()
+        );
+        this.debugLogger.log("retrieved sharedContext", this.sharedContext);
+        this.emit("connected", { guest: this, connection });
+      } catch (e) {
+        this.emit("error", { guest: this, error: e });
+        this.debugLogger.error("Connection failed!", e);
+      }
+    }
+  };
+
+  // src/guest-ui.ts
+  var GuestUI = class extends Guest2 {
+    constructor(config) {
+      super(config);
+    }
+  };
+
+  // src/guest-server.ts
+  var GuestServer = class extends Guest2 {
+    getLocalMethods() {
+      return {
+        ...super.getLocalMethods(),
+        apis: this.localMethods
+      };
+    }
+    async register(implementedMethods) {
+      this.localMethods = implementedMethods;
+      return this._connect();
+    }
+  };
+
+  // src/index.ts
+  function createGuest(config) {
+    const guest = new GuestServer(config);
+    return guest;
+  }
+  async function attach(config) {
+    const guest = new GuestUI(config);
+    await guest._connect();
+    return guest;
+  }
+  async function register(config) {
+    const guest = new GuestServer(config);
+    await guest.register(config.methods);
+    return guest;
+  }
+  return __toCommonJS(src_exports);
+})();
+//# sourceMappingURL=index.js.map