@learncard/chapi-plugin 1.0.0

package/dist/chapi-plugin.esm.js

@@ -0,0 +1,1574 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/utils.js
+var RPC_ERRORS = {
+  ParseError: {
+    message: "Parse error",
+    code: -32700
+  },
+  InvalidRequest: {
+    message: "Invalid Request",
+    code: -32600
+  },
+  MethodNotFound: {
+    message: "Method not found",
+    code: -32601
+  },
+  InvalidParams: {
+    message: "Invalid params",
+    code: -32602
+  },
+  InternalError: {
+    message: "Internal Error",
+    code: -32603
+  },
+  ServerError: {
+    message: "Server error",
+    code: -32e3
+  }
+};
+function parseUrl(url, base) {
+  if (base === void 0) {
+    base = window.location.href;
+  }
+  if (typeof URL === "function") {
+    return new URL(url, base);
+  }
+  if (typeof url !== "string") {
+    throw new TypeError('"url" must be a string.');
+  }
+  if (!url.includes(":")) {
+    if (base.startsWith("http") && !url.startsWith("/")) {
+      url = base + "/" + url;
+    } else {
+      url = base + url;
+    }
+  }
+  const parser = document.createElement("a");
+  parser.href = url;
+  let origin = (parser.protocol || window.location.protocol) + "//";
+  if (parser.host) {
+    if (parser.protocol === "http:" && parser.port === "80" || parser.protocol === "https:" && parser.port === "443") {
+      origin += parser.hostname;
+    } else {
+      origin += parser.host;
+    }
+  } else {
+    origin += window.location.host;
+  }
+  let pathname = parser.pathname;
+  if (!pathname.startsWith("/")) {
+    pathname = "/" + pathname;
+  }
+  return {
+    host: parser.host || window.location.host,
+    hostname: parser.hostname,
+    origin,
+    protocol: parser.protocol,
+    pathname
+  };
+}
+__name(parseUrl, "parseUrl");
+function uuidv4(a, b) {
+  for (b = a = ""; a++ < 36; b += a * 51 & 52 ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16) : "-")
+    ;
+  return b;
+}
+__name(uuidv4, "uuidv4");
+function isValidMessage(message) {
+  return message && typeof message === "object" && message.jsonrpc === "2.0" && message.id && typeof message.id === "string";
+}
+__name(isValidMessage, "isValidMessage");
+function isValidRequest(message) {
+  return isValidMessage(message) && Array.isArray(message.params);
+}
+__name(isValidRequest, "isValidRequest");
+function isValidResponse(message) {
+  return isValidMessage(message) && !!("result" in message ^ "error" in message) && (!("error" in message) || isValidError(message.error));
+}
+__name(isValidResponse, "isValidResponse");
+function isValidError(error) {
+  return error && typeof error === "object" && typeof error.code === "number" && typeof error.message === "string";
+}
+__name(isValidError, "isValidError");
+function serializeError(error) {
+  const err = {
+    message: error.message
+  };
+  if (error.constructor.name !== "Error") {
+    err.constructor = error.constructor.name;
+  }
+  if ("name" in error) {
+    err.name = error.name;
+  }
+  if ("code" in error) {
+    err.code = error.code;
+  } else {
+    err.code = RPC_ERRORS.ServerError.code;
+  }
+  if ("details" in error) {
+    err.details = error.details;
+  }
+  return err;
+}
+__name(serializeError, "serializeError");
+function deserializeError(error) {
+  let err;
+  if (error.constructor === "DOMException") {
+    err = new DOMException(error.message, error.name);
+  } else {
+    err = new Error(error.message);
+    if ("code" in error) {
+      err.code = error.code;
+    }
+  }
+  if (error.details) {
+    err.details = error.details;
+  }
+  return err;
+}
+__name(deserializeError, "deserializeError");
+function createMessageListener({ listener: listener2, origin, handle, expectRequest }) {
+  if (isHandlePromise(handle)) {
+    const promise = handle;
+    handle = false;
+    promise.then((h) => handle = h);
+  }
+  return (e) => {
+    if (!(e.source === handle && e.origin === origin && (expectRequest && isValidRequest(e.data) || !expectRequest && isValidResponse(e.data)))) {
+      return;
+    }
+    listener2(e.data, e);
+  };
+}
+__name(createMessageListener, "createMessageListener");
+function destructureMethodName(fqMethodName) {
+  let [name, ...rest] = fqMethodName.split(".");
+  const method = rest.pop();
+  name = [name, ...rest].join(".");
+  return { name, method };
+}
+__name(destructureMethodName, "destructureMethodName");
+function isHandlePromise(handle) {
+  try {
+    return typeof handle.then === "function";
+  } catch (e) {
+  }
+  return false;
+}
+__name(isHandlePromise, "isHandlePromise");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/Client.js
+var RPC_CLIENT_CALL_TIMEOUT = 3e4;
+var Client = class {
+  constructor() {
+    this.origin = null;
+    this._handle = null;
+    this._listener = null;
+    this._pending = /* @__PURE__ */ new Map();
+  }
+  async connect(origin, options) {
+    if (this._listener) {
+      throw new Error("Already connected.");
+    }
+    options = options || {};
+    const self = this;
+    self.origin = parseUrl(origin).origin;
+    self._handle = options.handle || window.opener || window.parent;
+    const pending = self._pending;
+    self._listener = createMessageListener({
+      origin: self.origin,
+      handle: self._handle,
+      expectRequest: false,
+      listener: (message) => {
+        if (!pending.has(message.id)) {
+          return;
+        }
+        const { resolve, reject, cancelTimeout } = pending.get(message.id);
+        cancelTimeout();
+        if ("result" in message) {
+          return resolve(message.result);
+        }
+        reject(deserializeError(message.error));
+      }
+    });
+    window.addEventListener("message", self._listener);
+    return new Injector(self);
+  }
+  async send(qualifiedMethodName, parameters, {
+    timeout = RPC_CLIENT_CALL_TIMEOUT
+  }) {
+    if (!this._listener) {
+      throw new Error("RPC client not connected.");
+    }
+    const self = this;
+    const message = {
+      jsonrpc: "2.0",
+      id: uuidv4(),
+      method: qualifiedMethodName,
+      params: parameters
+    };
+    if (isHandlePromise(self._handle)) {
+      const handle = await self._handle;
+      handle.postMessage(message, self.origin);
+    } else {
+      self._handle.postMessage(message, self.origin);
+    }
+    return new Promise((resolve, reject) => {
+      const pending = self._pending;
+      let cancelTimeout;
+      if (timeout > 0) {
+        const timeoutId = setTimeout(() => {
+          pending.delete(message.id);
+          reject(new Error("RPC call timed out."));
+        }, timeout);
+        cancelTimeout = /* @__PURE__ */ __name(() => {
+          pending.delete(message.id);
+          clearTimeout(timeoutId);
+        }, "cancelTimeout");
+      } else {
+        cancelTimeout = /* @__PURE__ */ __name(() => {
+          pending.delete(message.id);
+        }, "cancelTimeout");
+      }
+      pending.set(message.id, { resolve, reject, cancelTimeout });
+    });
+  }
+  close() {
+    if (this._listener) {
+      window.removeEventListener("message", this._listener);
+      this._handle = this.origin = this._listener = null;
+      for (const value of this._pending.values()) {
+        value.reject(new Error("RPC client closed."));
+      }
+      this._pending = /* @__PURE__ */ new Map();
+    }
+  }
+};
+__name(Client, "Client");
+var Injector = class {
+  constructor(client) {
+    this.client = client;
+    this._apis = /* @__PURE__ */ new Map();
+  }
+  define(name, definition) {
+    if (!(name && typeof name === "string")) {
+      throw new TypeError("`name` must be a non-empty string.");
+    }
+    if (!(definition && typeof definition === "object" && Array.isArray(definition.functions))) {
+      throw new TypeError(
+        "`definition.function` must be an array of function names or function definition objects to be defined."
+      );
+    }
+    const self = this;
+    const api = {};
+    definition.functions.forEach((fn) => {
+      if (typeof fn === "string") {
+        fn = { name: fn, options: {} };
+      }
+      api[fn.name] = async function() {
+        return self.client.send(
+          name + "." + fn.name,
+          [...arguments],
+          fn.options
+        );
+      };
+    });
+    self._apis[name] = api;
+    return api;
+  }
+  get(name, definition) {
+    const api = this._apis[name];
+    if (!api) {
+      if (definition) {
+        return this.define(name, definition);
+      }
+      throw new Error(`API "${name}" has not been defined.`);
+    }
+    return this._apis[name];
+  }
+};
+__name(Injector, "Injector");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/EventEmitter.js
+var EventEmitter = class {
+  constructor({ deserialize = /* @__PURE__ */ __name((e) => e, "deserialize"), waitUntil = /* @__PURE__ */ __name(async () => {
+  }, "waitUntil") } = {}) {
+    this._listeners = [];
+    this._deserialize = deserialize;
+    this._waitUntil = waitUntil;
+  }
+  async emit(event) {
+    event = this._deserialize(event);
+    (this._listeners[event.type] || []).forEach((l) => l(event));
+    return this._waitUntil(event);
+  }
+  addEventListener(eventType, fn) {
+    if (!this._listeners[eventType]) {
+      this._listeners[eventType] = [fn];
+    } else {
+      this._listeners[eventType].push(fn);
+    }
+  }
+  removeEventListener(eventType, fn) {
+    const listeners = this._listeners[eventType];
+    if (!listeners) {
+      return;
+    }
+    const idx = listeners.indexOf(fn);
+    if (idx !== -1) {
+      listeners.splice(idx, 1);
+    }
+  }
+};
+__name(EventEmitter, "EventEmitter");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/Server.js
+var Server = class {
+  constructor() {
+    this.origin = null;
+    this._handle = null;
+    this._apis = /* @__PURE__ */ new Map();
+  }
+  define(name, api) {
+    if (!(name && typeof name === "string")) {
+      throw new TypeError("`name` must be a non-empty string.");
+    }
+    if (!(api && api !== "object")) {
+      throw new TypeError("`api` must be an object.");
+    }
+    if (name in this._apis) {
+      throw new Error(`The "${name}" API is already defined.`);
+    }
+    this._apis[name] = api;
+  }
+  async listen(origin, options) {
+    if (this._listener) {
+      throw new Error("Already listening.");
+    }
+    options = options || {};
+    const self = this;
+    self.origin = parseUrl(origin).origin;
+    self._handle = options.handle || window.opener || window.parent;
+    const ignoreUnknownApi = options.ignoreUnknownApi === "true" || false;
+    self._listener = createMessageListener({
+      origin: self.origin,
+      handle: self._handle,
+      expectRequest: true,
+      listener: (message) => {
+        const { name, method } = destructureMethodName(message.method);
+        const api = self._apis[name];
+        if (method && method.startsWith("_")) {
+          return sendMethodNotFound(self._handle, self.origin, message);
+        }
+        if (!api && ignoreUnknownApi) {
+          return;
+        }
+        if (!api || typeof api[method] !== "function") {
+          return sendMethodNotFound(self._handle, self.origin, message);
+        }
+        const fn = api[method];
+        (async () => {
+          const response = {
+            jsonrpc: "2.0",
+            id: message.id
+          };
+          try {
+            response.result = await fn.apply(api, message.params);
+          } catch (e) {
+            response.error = serializeError(e);
+          }
+          if (self._handle) {
+            if (isHandlePromise(self._handle)) {
+              self._handle.then((h) => h.postMessage(response, self.origin));
+            } else {
+              self._handle.postMessage(response, self.origin);
+            }
+          }
+        })();
+      }
+    });
+    window.addEventListener("message", self._listener);
+  }
+  close() {
+    if (this._listener) {
+      window.removeEventListener("message", this._listener);
+      this._handle = this.origin = this._listener = null;
+    }
+  }
+};
+__name(Server, "Server");
+function sendMethodNotFound(handle, origin, message) {
+  const response = {
+    jsonrpc: "2.0",
+    id: message.id,
+    error: Object.assign({}, RPC_ERRORS.MethodNotFound)
+  };
+  if (isHandlePromise(handle)) {
+    return handle.then((h) => h.postMessage(response, origin));
+  } else {
+    return handle.postMessage(response, origin);
+  }
+}
+__name(sendMethodNotFound, "sendMethodNotFound");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/WebApp.js
+var WebApp = class {
+  constructor(relyingOrigin) {
+    this.relyingOrigin = parseUrl(relyingOrigin).origin;
+    this.client = null;
+    this.injector = null;
+    this.client = new Client();
+    this.server = new Server();
+    this._control = null;
+    this._connected = false;
+  }
+  async connect() {
+    this.injector = await this.client.connect(this.relyingOrigin);
+    this._connected = true;
+    this._control = this.injector.define("core.control", {
+      functions: ["ready", "show", "hide"]
+    });
+    this.server.listen(this.relyingOrigin);
+    return this.injector;
+  }
+  async ready() {
+    if (!this._connected) {
+      throw new Error('WebApp not connected. Did you call ".connect()"?');
+    }
+    await this._control.ready();
+    return this;
+  }
+  close() {
+    if (this._connected) {
+      this.server.close();
+      this.client.close();
+      this._connected = false;
+    }
+  }
+  async show() {
+    if (!this._connected) {
+      throw new Error(
+        'Cannot "show" yet; not connected. Did you call ".connect()"?'
+      );
+    }
+    return this._control.show();
+  }
+  async hide() {
+    if (!this._connected) {
+      throw new Error(
+        'Cannot "hide" yet; not connected. Did you call ".connect()?"'
+      );
+    }
+    return this._control.hide();
+  }
+};
+__name(WebApp, "WebApp");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/WebAppWindowDialog.js
+var WebAppWindowDialog = class {
+  constructor() {
+    this._closeEventListeners = /* @__PURE__ */ new Set();
+  }
+  addEventListener(name, listener2) {
+    if (name !== "close") {
+      throw new Error(`Unknown event "${name}".`);
+    }
+    if (typeof listener2 !== "function") {
+      throw new TypeError('"listener" must be a function.');
+    }
+    this._closeEventListeners.add(listener2);
+  }
+  removeEventListener(name, listener2) {
+    if (name !== "close") {
+      throw new Error(`Unknown event "${name}".`);
+    }
+    if (typeof listener2 !== "function") {
+      throw new TypeError('"listener" must be a function.');
+    }
+    this._closeEventListeners.delete(listener2);
+  }
+  show() {
+  }
+  close() {
+    for (const listener2 of this._closeEventListeners) {
+      listener2({});
+    }
+  }
+  destroy() {
+    this._closeEventListeners.clear();
+  }
+};
+__name(WebAppWindowDialog, "WebAppWindowDialog");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/WebAppWindowInlineDialog.js
+var WebAppWindowInlineDialog = class extends WebAppWindowDialog {
+  constructor({ url, handle, className }) {
+    super();
+    this.url = url;
+    this.handle = handle;
+    this.dialog = document.createElement("dialog");
+    applyStyle(this.dialog, {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      width: "100%",
+      height: "100%",
+      "max-width": "100%",
+      "max-height": "100%",
+      display: "none",
+      margin: 0,
+      padding: 0,
+      border: "none",
+      background: "transparent",
+      color: "black",
+      "box-sizing": "border-box",
+      overflow: "hidden",
+      "user-select": "none",
+      "z-index": 1e6
+    });
+    this.dialog.className = "web-app-window";
+    if (typeof className === "string") {
+      this.dialog.className = this.dialog.className + " " + className;
+    }
+    const style = document.createElement("style");
+    style.appendChild(
+      document.createTextNode(`dialog.web-app-window::backdrop {
+        background-color: transparent;
+      }`)
+    );
+    this.container = document.createElement("div");
+    applyStyle(this.container, {
+      position: "relative",
+      width: "100%",
+      height: "100%",
+      margin: 0,
+      padding: 0,
+      display: "flex",
+      "flex-direction": "column"
+    });
+    this.container.className = "web-app-window-backdrop";
+    this.iframe = document.createElement("iframe");
+    this.iframe.src = url;
+    this.iframe.scrolling = "auto";
+    applyStyle(this.iframe, {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      width: "100%",
+      height: "100%",
+      border: "none",
+      background: "transparent",
+      overflow: "hidden",
+      margin: 0,
+      padding: 0,
+      "flex-grow": 1,
+      "user-select": "none"
+    });
+    this.dialog.appendChild(style);
+    this.container.appendChild(this.iframe);
+    this.dialog.appendChild(this.container);
+    this.dialog.addEventListener("cancel", (e) => {
+      e.preventDefault();
+      this.hide();
+    });
+    document.body.appendChild(this.dialog);
+    this.handle = this.iframe.contentWindow;
+  }
+  show() {
+    this.dialog.style.display = "block";
+    if (this.dialog.showModal) {
+      this.dialog.showModal();
+    }
+    try {
+      this.dialog.style.pointerEvents = "none";
+    } catch (e) {
+    }
+    setTimeout(() => {
+      try {
+        this.dialog.style.pointerEvents = "";
+      } catch (e) {
+      }
+    }, 32);
+  }
+  close() {
+    this.dialog.style.display = "none";
+    if (this.dialog.close) {
+      try {
+        this.dialog.close();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    super.close();
+  }
+  destroy() {
+    this.dialog.parentNode.removeChild(this.dialog);
+    super.destroy();
+  }
+};
+__name(WebAppWindowInlineDialog, "WebAppWindowInlineDialog");
+function applyStyle(element, style) {
+  for (const name in style) {
+    element.style[name] = style[name];
+  }
+}
+__name(applyStyle, "applyStyle");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/WebAppWindowPopupDialog.js
+var WebAppWindowPopupDialog = class extends WebAppWindowDialog {
+  constructor({ url, handle, bounds = { width: 500, height: 400 } }) {
+    super();
+    this.url = url;
+    this.handle = handle;
+    this._locationChanging = false;
+    if (!handle) {
+      this._openWindow({ url, name: "web-app-window", bounds });
+    }
+    this.destroyed = false;
+    this._removeListeners = () => {
+    };
+  }
+  show() {
+  }
+  close() {
+    this.destroy();
+  }
+  destroy() {
+    if (this.handle && !this.destroyed) {
+      this.handle.close();
+      super.close();
+      this.handle = null;
+      this.destroyed = true;
+      this._removeListeners();
+      super.destroy();
+    }
+  }
+  isClosed() {
+    return !this.handle || this.handle.closed;
+  }
+  _openWindow({ url, name, bounds }) {
+    const { x, y } = bounds;
+    let { width = 500, height = 400 } = bounds;
+    width = Math.min(width, window.innerWidth);
+    height = Math.min(height, window.innerHeight);
+    const left = Math.floor(x !== void 0 ? x : window.screenX + (window.innerWidth - width) / 2);
+    const top = Math.floor(y !== void 0 ? y : window.screenY + (window.innerHeight - height) / 2);
+    const features = `popup=yes,menubar=no,location=no,resizable=no,scrollbars=no,status=no,width=${width},height=${height},left=${left},top=${top}`;
+    this._locationChanging = true;
+    this.handle = window.open(url, name, features);
+    this._addListeners();
+  }
+  setLocation(url) {
+    this.url = url;
+    this._locationChanging = true;
+    this.handle.location.replace(url);
+  }
+  _addListeners() {
+    const destroyDialog = /* @__PURE__ */ __name(() => this.destroy(), "destroyDialog");
+    const loadDialog = /* @__PURE__ */ __name(() => {
+      this._locationChanging = false;
+    }, "loadDialog");
+    const unloadDialog = /* @__PURE__ */ __name(() => {
+      if (this._locationChanging) {
+        return;
+      }
+      this.destroy();
+    }, "unloadDialog");
+    this.handle.addEventListener("unload", unloadDialog);
+    this.handle.addEventListener("load", loadDialog);
+    window.addEventListener("beforeUnload", destroyDialog, { once: true });
+    const intervalId = setInterval(() => {
+      if (this.isClosed()) {
+        this.destroy();
+        clearInterval(intervalId);
+      }
+    }, 250);
+    this._removeListeners = () => {
+      clearInterval(intervalId);
+      this.handle.removeListener("unload", unloadDialog);
+      this.handle.removeListener("load", loadDialog);
+      window.removeEventListener("beforeUnload", destroyDialog);
+    };
+  }
+};
+__name(WebAppWindowPopupDialog, "WebAppWindowPopupDialog");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/WebAppWindow.js
+var LOAD_WINDOW_TIMEOUT = 6e4;
+var WebAppWindow = class {
+  constructor(url, {
+    timeout = LOAD_WINDOW_TIMEOUT,
+    dialog = null,
+    handle,
+    popup = false,
+    className = null,
+    customize = null,
+    bounds
+  } = {}) {
+    this.visible = false;
+    this.dialog = dialog;
+    this.handle = null;
+    this.popup = popup;
+    this.windowControl = null;
+    this._destroyed = false;
+    this._ready = false;
+    this._private = {};
+    this._timeoutId = null;
+    if (handle && handle._dialog) {
+      this.dialog = dialog = handle._dialog;
+    }
+    this._private._readyPromise = new Promise((resolve, reject) => {
+      this._timeoutId = setTimeout(
+        () => reject(new DOMException(
+          "Loading Web application window timed out.",
+          "TimeoutError"
+        )),
+        timeout
+      );
+      this._private._resolveReady = (value) => {
+        clearTimeout(this.timeoutId);
+        this._timeoutId = null;
+        resolve(value);
+      };
+      this._private._rejectReady = (err) => {
+        clearTimeout(this.timeoutId);
+        this._timeoutId = null;
+        reject(err);
+      };
+    });
+    this._private.isReady = async () => {
+      return this._private._readyPromise;
+    };
+    this._private.destroy = () => {
+      if (this._timeoutId) {
+        this._private._rejectReady(new DOMException(
+          "Web application window closed before ready.",
+          "AbortError"
+        ));
+      }
+      if (!this._destroyed) {
+        this.dialog.destroy();
+        this.dialog = null;
+        this._destroyed = true;
+      }
+    };
+    if (customize) {
+      if (!typeof customize === "function") {
+        throw new TypeError("`options.customize` must be a function.");
+      }
+    }
+    if (!this.dialog) {
+      if (this.popup) {
+        this.dialog = new WebAppWindowPopupDialog({ url, handle, bounds });
+      } else {
+        this.dialog = new WebAppWindowInlineDialog({ url, handle, className });
+      }
+    }
+    if (this.popup && bounds) {
+      let { x, y, width = 500, height = 400 } = bounds;
+      width = Math.min(width, window.innerWidth);
+      height = Math.min(height + 30, window.innerHeight);
+      x = Math.floor(x !== void 0 ? x : window.screenX + (window.innerWidth - width) / 2);
+      y = Math.floor(y !== void 0 ? y : window.screenY + (window.innerHeight - height) / 2 + 15);
+      this.dialog.handle.resizeTo(width, height);
+      this.dialog.handle.moveTo(x, y);
+    }
+    this.handle = this.dialog.handle;
+    if (customize) {
+      try {
+        customize({
+          dialog: this.dialog.dialog,
+          container: this.dialog.container,
+          iframe: this.dialog.iframe,
+          webAppWindow: this
+        });
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+  ready() {
+    this._ready = true;
+    this._private._resolveReady(true);
+  }
+  show() {
+    if (!this.visible) {
+      this.visible = true;
+      const body = document.querySelector("body");
+      this._bodyOverflowStyle = body.style.overflow;
+      body.style.overflow = "hidden";
+      if (!this._destroyed) {
+        this.dialog.show();
+      } else if (this.windowControl.show) {
+        this.windowControl.show();
+      }
+    }
+  }
+  hide() {
+    if (this.visible) {
+      this.visible = false;
+      const body = document.querySelector("body");
+      if (this._bodyOverflowStyle) {
+        body.style.overflow = this._bodyOverflowStyle;
+      } else {
+        body.style.overflow = "";
+      }
+      if (!this._destroyed) {
+        this.dialog.close();
+      } else if (this.windowControl.hide) {
+        this.windowControl.hide();
+      }
+    }
+  }
+};
+__name(WebAppWindow, "WebAppWindow");
+
+// ../../../node_modules/.pnpm/web-request-rpc@2.0.3/node_modules/web-request-rpc/WebAppContext.js
+var WEB_APP_CONTEXT_LOAD_TIMEOUT = 1e4;
+var WebAppContext = class {
+  constructor() {
+    this.client = new Client();
+    this.server = new Server();
+    this.injector = null;
+    this.control = null;
+    this.loaded = false;
+    this.closed = false;
+  }
+  async createWindow(url, {
+    timeout = WEB_APP_CONTEXT_LOAD_TIMEOUT,
+    iframe,
+    dialog = null,
+    popup = false,
+    handle,
+    windowControl,
+    className,
+    customize,
+    bounds
+  } = {}) {
+    if (this.loaded) {
+      throw new Error("AppContext already loaded.");
+    }
+    this.loaded = true;
+    this.control = new WebAppWindow(url, {
+      timeout,
+      dialog,
+      iframe,
+      popup,
+      handle,
+      windowControl,
+      className,
+      customize,
+      bounds
+    });
+    window.addEventListener("pagehide", () => this.close(), { once: true });
+    this.server.define("core.control", this.control);
+    const origin = parseUrl(url).origin;
+    this.server.listen(origin, {
+      handle: this.control.handle,
+      ignoreUnknownApi: true
+    });
+    await this.control._private.isReady();
+    this.injector = await this.client.connect(origin, {
+      handle: this.control.handle
+    });
+    return this.injector;
+  }
+  close() {
+    if (!this.closed) {
+      this.closed = true;
+      this.control._private.destroy();
+      this.server.close();
+      this.client.close();
+    }
+  }
+};
+__name(WebAppContext, "WebAppContext");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialRequestEvent.js
+var CredentialRequestEvent = class {
+  constructor({
+    credentialHandler,
+    credentialRequestOrigin,
+    credentialRequestOptions,
+    hintKey
+  }) {
+    this.type = "credentialrequest";
+    this._credentialHandler = credentialHandler;
+    this.credentialRequestOrigin = credentialRequestOrigin;
+    this.credentialRequestOptions = credentialRequestOptions;
+    this.hintKey = hintKey;
+  }
+  async openWindow(url) {
+    await this._credentialHandler.show();
+    const appWindow = new WebAppWindow(url, {
+      className: "credential-handler"
+    });
+    appWindow.ready();
+    appWindow.show();
+    appWindow.handle._dialog = appWindow.dialog;
+    return appWindow.handle;
+  }
+  respondWith(handlerResponse) {
+    this._promise = handlerResponse;
+  }
+};
+__name(CredentialRequestEvent, "CredentialRequestEvent");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialStoreEvent.js
+var CredentialStoreEvent = class {
+  constructor({
+    credentialHandler,
+    credentialRequestOrigin,
+    credential,
+    hintKey
+  }) {
+    this.type = "credentialstore";
+    this._credentialHandler = credentialHandler;
+    this.credentialRequestOrigin = credentialRequestOrigin;
+    this.credential = credential;
+    this.hintKey = hintKey;
+  }
+  async openWindow(url) {
+    await this._credentialHandler.show();
+    const appWindow = new WebAppWindow(url);
+    appWindow.ready();
+    appWindow.show();
+    appWindow.handle._dialog = appWindow.dialog;
+    return appWindow.handle;
+  }
+  respondWith(handlerResponse) {
+    this._promise = handlerResponse;
+  }
+};
+__name(CredentialStoreEvent, "CredentialStoreEvent");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialHandlerService.js
+var CredentialHandlerService = class {
+  constructor(credentialHandler) {
+    this._credentialHandler = credentialHandler;
+  }
+  async request(credentialRequestEvent) {
+    return await this._credentialHandler._emitter.emit(
+      new CredentialRequestEvent(Object.assign(
+        { credentialHandler: this._credentialHandler },
+        credentialRequestEvent
+      ))
+    );
+  }
+  async store(credentialStoreEvent) {
+    return await this._credentialHandler._emitter.emit(
+      new CredentialStoreEvent(Object.assign(
+        { credentialHandler: this._credentialHandler },
+        credentialStoreEvent
+      ))
+    );
+  }
+};
+__name(CredentialHandlerService, "CredentialHandlerService");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialHandler.js
+var EVENT_TYPES = ["credentialrequest", "credentialstore"];
+var CredentialHandler = class extends WebApp {
+  constructor(mediatorOrigin, inline = false) {
+    if (typeof mediatorOrigin !== "string") {
+      throw new TypeError('"mediatorOrigin" must be a string.');
+    }
+    super(mediatorOrigin, inline);
+    this._emitter = new EventEmitter({
+      async waitUntil(event) {
+        return event._promise || Promise.reject(
+          new DOMException(
+            'No "credentialrequest" event handler found.',
+            "NotFoundError"
+          )
+        );
+      }
+    });
+  }
+  async connect() {
+    const injector = await super.connect();
+    this.server.define("credentialHandler", new CredentialHandlerService(this));
+    await this.ready();
+    return injector;
+  }
+  addEventListener(eventType, fn) {
+    if (!EVENT_TYPES.includes(eventType)) {
+      throw new DOMException(
+        `Unsupported event type "${eventType}"`,
+        "NotSupportedError"
+      );
+    }
+    return this._emitter.addEventListener(eventType, fn);
+  }
+  removeEventListener(eventType, fn) {
+    if (!EVENT_TYPES.includes(eventType)) {
+      throw new DOMException(
+        `Unsupported event type "${eventType}"`,
+        "NotSupportedError"
+      );
+    }
+    return this._emitter.removeEventListener(eventType, fn);
+  }
+};
+__name(CredentialHandler, "CredentialHandler");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialHints.js
+var CredentialHints = class {
+  constructor(url, injector) {
+    const remote = injector.get("credentialHints", {
+      functions: ["delete", "get", "keys", "has", "set", "clear"]
+    });
+    for (let methodName in remote) {
+      if (methodName !== "set") {
+        const method = remote[methodName].bind(this, url);
+        this[methodName] = function(...args) {
+          this._deprecateNotice();
+          return method(...args);
+        };
+      }
+    }
+    this._remoteSet = remote.set.bind(this, url);
+  }
+  async set(hintKey, credentialHint) {
+    this._deprecateNotice();
+    credentialHint.icons = credentialHint.icons || [];
+    const promises = credentialHint.icons.map((icon) => imageToDataUrl(icon.src).then((fetchedImage) => {
+      icon.fetchedImage = fetchedImage;
+    }));
+    await Promise.all(promises);
+    return this._remoteSet(hintKey, credentialHint);
+  }
+  _deprecateNotice() {
+    console.warn("Credential hints are deprecated and no longer used.");
+  }
+};
+__name(CredentialHints, "CredentialHints");
+function imageToDataUrl(url) {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.crossOrigin = "Anonymous";
+    img.onload = () => {
+      let canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      canvas.height = img.height;
+      canvas.width = img.width;
+      ctx.drawImage(img, 0, 0);
+      const dataUrl = canvas.toDataURL();
+      resolve(dataUrl);
+      canvas = null;
+    };
+    img.onerror = () => resolve(null);
+    img.src = url;
+  });
+}
+__name(imageToDataUrl, "imageToDataUrl");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialManager.js
+var CredentialManager = class {
+  constructor(url, injector) {
+    if (!(url && typeof url === "string")) {
+      throw new TypeError('"url" must be a non-empty string.');
+    }
+    this.hints = new CredentialHints(url, injector);
+  }
+  static async requestPermission() {
+    const status = await navigator.credentialsPolyfill.permissions.request(
+      { name: "credentialhandler" }
+    );
+    return status.state;
+  }
+};
+__name(CredentialManager, "CredentialManager");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialHandlerRegistration.js
+var CredentialHandlerRegistration = class {
+  constructor(url, injector) {
+    if (!(url && typeof url === "string")) {
+      throw new TypeError('"url" must be a non-empty string.');
+    }
+    this.credentialManager = new CredentialManager(url, injector);
+  }
+};
+__name(CredentialHandlerRegistration, "CredentialHandlerRegistration");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialHandlers.js
+var CredentialHandlers = class {
+  constructor(injector) {
+    this._init = (async () => {
+      this._injector = await injector;
+      this._remote = this._injector.get("credentialHandlers", {
+        functions: [
+          "register",
+          "unregister",
+          "getRegistration",
+          "hasRegistration"
+        ]
+      });
+    })();
+  }
+  async register(url) {
+    this._deprecateNotice();
+    await this._init;
+    url = await this._remote.register("credential", url);
+    return new CredentialHandlerRegistration(url, this._injector);
+  }
+  async unregister(url) {
+    this._deprecateNotice();
+    await this._init;
+    return this._remote.unregister("credential", url);
+  }
+  async getRegistration(url) {
+    this._deprecateNotice();
+    await this._init;
+    url = await this._remote.getRegistration("credential", url);
+    if (!url) {
+      return null;
+    }
+    return new CredentialHandlerRegistration(url, this._injector);
+  }
+  async hasRegistration(url) {
+    this._deprecateNotice();
+    await this._init;
+    return await this._remote.hasRegistration("credential", url);
+  }
+  _deprecateNotice() {
+    console.warn(
+      'Credential handler registration APIs are deprecated. The credential handler specified in "manifest.json" is now automatically registered when a user grants permission to install a credential handler via "CredentialManager.requestPermission()".'
+    );
+  }
+};
+__name(CredentialHandlers, "CredentialHandlers");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/WebCredential.js
+var WebCredential2 = class {
+  constructor(dataType, data, { recommendedHandlerOrigins = [] } = {}) {
+    if (typeof dataType !== "string") {
+      throw new TypeError('"dataType" must be a string.');
+    }
+    this.type = "web";
+    this.dataType = dataType;
+    this.data = data;
+    this.options = { recommendedHandlerOrigins };
+  }
+};
+__name(WebCredential2, "WebCredential");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/CredentialsContainer.js
+var CREDENTIAL_GET_TIMEOUT = 0;
+var CREDENTIAL_STORE_TIMEOUT = 0;
+var CredentialsContainer = class {
+  constructor(injector) {
+    this._nativeCredentialsContainer = {
+      get: navigator.credentials && navigator.credentials.get && navigator.credentials.get.bind(navigator.credentials),
+      store: navigator.credentials && navigator.credentials.store && navigator.credentials.store.bind(navigator.credentials)
+    };
+    this._init = (async () => {
+      this._remote = (await injector).get("credentialsContainer", {
+        functions: [
+          { name: "get", options: { timeout: CREDENTIAL_GET_TIMEOUT } },
+          { name: "store", options: { timeout: CREDENTIAL_STORE_TIMEOUT } }
+        ]
+      });
+    })();
+  }
+  async get(options = {}) {
+    if (options.web) {
+      await this._init;
+      const credential = await this._remote.get(options);
+      if (!credential) {
+        return null;
+      }
+      return new WebCredential2(credential.dataType, credential.data);
+    }
+    if (this._nativeCredentialsContainer.get) {
+      return this._nativeCredentialsContainer.get(options);
+    }
+    throw new DOMException("Not implemented.", "NotSupportedError");
+  }
+  async store(credential) {
+    if (credential instanceof WebCredential2) {
+      await this._init;
+      const result = await this._remote.store(credential);
+      if (!result) {
+        return null;
+      }
+      return new WebCredential2(result.dataType, result.data);
+    }
+    if (this._nativeCredentialsContainer.store) {
+      return this._nativeCredentialsContainer.store(credential);
+    }
+    throw new DOMException("Not implemented.", "NotSupportedError");
+  }
+};
+__name(CredentialsContainer, "CredentialsContainer");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/PermissionManager.js
+var PERMISSION_REQUEST_TIMEOUT = 0;
+var PermissionManager = class {
+  constructor(injector) {
+    this._init = (async () => {
+      this._remote = (await injector).get("permissionManager", {
+        functions: [
+          "query",
+          { name: "request", options: { timeout: PERMISSION_REQUEST_TIMEOUT } },
+          "revoke"
+        ]
+      });
+    })();
+  }
+  async query(permissionDesc) {
+    await this._init;
+    return await this._remote.query(permissionDesc);
+  }
+  async request(permissionDesc) {
+    await this._init;
+    return await this._remote.request(permissionDesc);
+  }
+  async revoke(permissionDesc) {
+    await this._init;
+    return await this._remote.revoke(permissionDesc);
+  }
+};
+__name(PermissionManager, "PermissionManager");
+
+// ../../../node_modules/.pnpm/credential-handler-polyfill@3.1.0/node_modules/credential-handler-polyfill/index.js
+var DEFAULT_MEDIATOR_ORIGIN = "https://authn.io";
+var loaded;
+async function loadOnce(options) {
+  if (loaded) {
+    return loaded;
+  }
+  loaded = true;
+  return load(options);
+}
+__name(loadOnce, "loadOnce");
+async function load(options = {
+  mediatorOrigin: DEFAULT_MEDIATOR_ORIGIN
+}) {
+  _assertSecureContext();
+  let mediatorUrl;
+  if (typeof options === "string") {
+    mediatorUrl = options;
+  } else if (options && typeof options === "object" && typeof options.mediatorOrigin === "string") {
+    mediatorUrl = `${options.mediatorOrigin}/mediator`;
+  } else {
+    throw new Error(
+      '"options.mediatorOrigin" must be a string expressing the origin of the mediator.'
+    );
+  }
+  const appContext = new WebAppContext();
+  const injector = appContext.createWindow(mediatorUrl, {
+    className: "credential-mediator",
+    timeout: 3e4
+  });
+  const style = document.createElement("style");
+  style.appendChild(document.createTextNode(
+    `dialog.web-app-window.credential-mediator > .web-app-window-backdrop {
+      background-color: rgba(0, 0, 0, 0.25);
+    }`
+  ));
+  document.body.appendChild(style);
+  const polyfill = {};
+  polyfill.permissions = new PermissionManager(injector);
+  polyfill.CredentialHandlers = new CredentialHandlers(injector);
+  polyfill.CredentialHandler = CredentialHandler;
+  polyfill.CredentialManager = CredentialManager;
+  polyfill.credentials = new CredentialsContainer(injector);
+  polyfill.WebCredential = WebCredential2;
+  navigator.credentialsPolyfill = polyfill;
+  if ("credentials" in navigator) {
+    navigator.credentials.get = polyfill.credentials.get.bind(
+      polyfill.credentials
+    );
+    navigator.credentials.store = polyfill.credentials.store.bind(
+      polyfill.credentials
+    );
+  } else {
+    navigator.credentials = polyfill.credentials;
+  }
+  window.CredentialManager = CredentialManager;
+  window.WebCredential = WebCredential2;
+  return polyfill;
+}
+__name(load, "load");
+function _assertSecureContext() {
+  if (!window.isSecureContext) {
+    throw new DOMException("SecurityError", "The operation is insecure.");
+  }
+}
+__name(_assertSecureContext, "_assertSecureContext");
+
+// ../../../node_modules/.pnpm/web-credential-handler@2.0.2/node_modules/web-credential-handler/CredentialEventProxy.js
+var PROXY_EVENT_TIMEOUT = 6e4;
+var CredentialEventProxy = class extends WebApp {
+  constructor() {
+    super(window.location.origin);
+  }
+  async receive() {
+    const self = this;
+    await self.connect();
+    return new Promise((resolveReceive, rejectReceive) => {
+      const timeoutId = setTimeout(() => {
+        rejectReceive(new Error("Timed out waiting to receive event."));
+      }, PROXY_EVENT_TIMEOUT);
+      self.server.define("credentialEventProxy", {
+        async send(event) {
+          resolveReceive(event);
+          clearTimeout(timeoutId);
+          return new Promise((resolveSend, rejectSend) => {
+            event.respondWith = (promise) => {
+              try {
+                resolveSend(promise);
+              } catch (e) {
+                rejectSend(e);
+              }
+            };
+          });
+        }
+      });
+      self.ready();
+    });
+  }
+};
+__name(CredentialEventProxy, "CredentialEventProxy");
+
+// ../../../node_modules/.pnpm/web-credential-handler@2.0.2/node_modules/web-credential-handler/index.js
+var DEFAULT_MEDIATOR = "https://authn.io";
+async function installHandler() {
+  const CredentialManager2 = navigator.credentialsPolyfill.CredentialManager;
+  const result = await CredentialManager2.requestPermission();
+  if (result !== "granted") {
+    throw new Error("Permission denied.");
+  }
+}
+__name(installHandler, "installHandler");
+async function activateHandler({
+  mediatorOrigin = DEFAULT_MEDIATOR,
+  get,
+  store
+}) {
+  if (!(get || store)) {
+    throw new Error('"get" or "store" function(s) must be specified.');
+  }
+  const CredentialHandler2 = navigator.credentialsPolyfill.CredentialHandler;
+  const self = new CredentialHandler2(mediatorOrigin);
+  if (get) {
+    if (typeof get !== "function") {
+      throw new TypeError('"get" must be a function.');
+    }
+    self.addEventListener("credentialrequest", (event) => listener({ event, get }));
+  }
+  if (store) {
+    if (typeof store !== "function") {
+      throw new TypeError('"store" must be a function.');
+    }
+    self.addEventListener("credentialstore", (event) => listener({ event, store }));
+  }
+  await self.connect();
+}
+__name(activateHandler, "activateHandler");
+async function receiveCredentialEvent() {
+  const proxy = new CredentialEventProxy();
+  return proxy.receive();
+}
+__name(receiveCredentialEvent, "receiveCredentialEvent");
+function listener({ event, get, store }) {
+  event.respondWith(createResponse({ event, get, store }));
+}
+__name(listener, "listener");
+async function createResponse({ event, get, store }) {
+  const result = await (get || store)({ event });
+  if (!(result && typeof result === "object")) {
+    throw new TypeError(
+      'Return value of "get" or "store" hook must be an object.'
+    );
+  }
+  if (result.type === "response") {
+    return { dataType: result.dataType, data: result.data };
+  }
+  if (result.type === "redirect") {
+    const appContext = new WebAppContext();
+    const handle = await event.openWindow(result.url);
+    const windowReady = appContext.createWindow(result.url, {
+      handle,
+      popup: false,
+      timeout: 6e5
+    });
+    const injector = await windowReady;
+    const proxy = injector.get("credentialEventProxy", {
+      functions: [{ name: "send", options: { timeout: 0 } }]
+    });
+    return proxy.send({
+      type: event.type,
+      credentialRequestOptions: event.credentialRequestOptions,
+      credentialRequestOrigin: event.credentialRequestOrigin,
+      credential: event.credential,
+      hintKey: event.hintKey
+    });
+  }
+  throw new Error(
+    'Return value of "get" or "store" must have a type of "response" or "redirect".'
+  );
+}
+__name(createResponse, "createResponse");
+
+// src/chapi.ts
+var getCHAPIPlugin = /* @__PURE__ */ __name(async () => {
+  if (typeof window === "undefined") {
+    return {
+      name: "CHAPI",
+      methods: {
+        installChapiHandler: async () => {
+          throw new Error("CHAPI is only available inside of a browser!");
+        },
+        activateChapiHandler: async () => {
+          throw new Error("CHAPI is only available inside of a browser!");
+        },
+        receiveChapiEvent: async () => {
+          throw new Error("CHAPI is only available inside of a browser!");
+        },
+        storeCredentialViaChapiDidAuth: async () => {
+          throw new Error("CHAPI is only available inside of a browser!");
+        },
+        storePresentationViaChapi: async () => {
+          throw new Error("CHAPI is only available inside of a browser!");
+        }
+      }
+    };
+  }
+  await loadOnce();
+  return {
+    name: "CHAPI",
+    displayName: "CHAPI",
+    description: "Credential Handler API. Allows sending/retrieving credentials across wallets and issuers",
+    methods: {
+      installChapiHandler: async () => installHandler(),
+      activateChapiHandler: async (_learnCard, {
+        mediatorOrigin = `https://authn.io/mediator?${encodeURIComponent(
+          window.location.origin
+        )}`,
+        get,
+        store
+      }) => {
+        return activateHandler({ mediatorOrigin, get, store });
+      },
+      receiveChapiEvent: async () => receiveCredentialEvent(),
+      storeCredentialViaChapiDidAuth: async (_learnCard, credential) => {
+        const challenge = crypto.randomUUID();
+        const domain = window.location.origin;
+        const vpr = {
+          web: {
+            VerifiablePresentation: {
+              query: { type: "DIDAuthentication" },
+              challenge,
+              domain
+            }
+          }
+        };
+        const res = await navigator.credentials.get(vpr);
+        if (!res)
+          return { success: false, reason: "did not auth" };
+        const verification = await _learnCard.invoke.verifyPresentation(res.data, {
+          challenge,
+          domain,
+          proofPurpose: "authentication"
+        });
+        if (verification.warnings.length > 0 || verification.errors.length > 0) {
+          return { success: false, reason: "auth failed verification" };
+        }
+        const subject = res.data?.proof?.verificationMethod?.split("#")[0];
+        if (!Array.isArray(credential.credentialSubject)) {
+          credential.credentialSubject.id = subject;
+        }
+        const vp = await _learnCard.invoke.getTestVp(
+          await _learnCard.invoke.issueCredential(credential)
+        );
+        const success = await _learnCard.invoke.storePresentationViaChapi(vp);
+        if (success)
+          return { success: true };
+        return { success: false, reason: "did not store" };
+      },
+      storePresentationViaChapi: async (_learnCard, presentation) => {
+        const wc = new WebCredential("VerifiablePresentation", presentation);
+        return window.navigator.credentials.store(wc);
+      }
+    }
+  };
+}, "getCHAPIPlugin");
+export {
+  getCHAPIPlugin
+};
+/*!
+ * A CredentialHandlerRegistration provides a CredentialManager to enable Web
+ * apps to register Profiles that can be presented to websites.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A CredentialRequestEvent is emitted when a request has been made for
+ * credentials.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A CredentialStoreEvent is emitted when a request has been made to
+ * store a credential.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A WebApp is a remote application that runs in a WebAppContext.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A WebCredential is a Credential that can be retrieved from or stored by a
+ * "credential handler" that runs in a third party Web application.
+ *
+ * Copyright (c) 2017-2021 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017-2018 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017-2023 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2018-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2022-2023 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * JSON-RPC for Web Request Polyfills.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * The core CredentialHandler class.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Utilities for Web Request RPC.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Wrapper for native CredentialsContainer that uses remote Credential Mediator
+ * for WebCredential-related operations.
+ *
+ * Copyright (c) 2017-2018 Digital Bazaar, Inc. All rights reserved.
+ */
+//# sourceMappingURL=chapi-plugin.esm.js.map