@whereby.com/browser-sdk 2.0.0-alpha9 → 2.0.0-beta2

package/dist/v2-beta2.js

@@ -0,0 +1,2000 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// node_modules/@ungap/weakmap/esm/index.js
+var self = {};
+try {
+  self.WeakMap = WeakMap;
+} catch (WeakMap2) {
+  self.WeakMap = function(id, Object2) {
+    "use strict";
+    var dP = Object2.defineProperty;
+    var hOP = Object2.hasOwnProperty;
+    var proto = WeakMap3.prototype;
+    proto.delete = function(key) {
+      return this.has(key) && delete key[this._];
+    };
+    proto.get = function(key) {
+      return this.has(key) ? key[this._] : void 0;
+    };
+    proto.has = function(key) {
+      return hOP.call(key, this._);
+    };
+    proto.set = function(key, value) {
+      dP(key, this._, { configurable: true, value });
+      return this;
+    };
+    return WeakMap3;
+    function WeakMap3(iterable) {
+      dP(this, "_", { value: "_@ungap/weakmap" + id++ });
+      if (iterable)
+        iterable.forEach(add, this);
+    }
+    function add(pair) {
+      this.set(pair[0], pair[1]);
+    }
+  }(Math.random(), Object);
+}
+var esm_default = self.WeakMap;
+
+// node_modules/uhyphen/esm/index.js
+var esm_default2 = (camel) => camel.replace(/(([A-Z0-9])([A-Z0-9][a-z]))|(([a-z])([A-Z]))/g, "$2$5-$3$6").toLowerCase();
+
+// node_modules/@ungap/event/esm/index.js
+var self2 = {};
+try {
+  self2.Event = new Event(".").constructor;
+} catch (Event2) {
+  try {
+    self2.Event = new CustomEvent(".").constructor;
+  } catch (Event3) {
+    self2.Event = function Event4(type, init2) {
+      if (!init2)
+        init2 = {};
+      var e = document.createEvent("Event");
+      var bubbles = !!init2.bubbles;
+      var cancelable = !!init2.cancelable;
+      e.initEvent(type, bubbles, cancelable);
+      try {
+        e.bubbles = bubbles;
+        e.cancelable = cancelable;
+      } catch (e2) {
+      }
+      return e;
+    };
+  }
+}
+var esm_default3 = self2.Event;
+
+// node_modules/@ungap/weakset/esm/index.js
+var self3 = {};
+try {
+  self3.WeakSet = WeakSet;
+} catch (WeakSet2) {
+  (function(WeakMap2) {
+    var all = new WeakMap2();
+    var proto = WeakSet3.prototype;
+    proto.add = function(value) {
+      return all.get(this).set(value, 1), this;
+    };
+    proto.delete = function(value) {
+      return all.get(this).delete(value);
+    };
+    proto.has = function(value) {
+      return all.get(this).has(value);
+    };
+    self3.WeakSet = WeakSet3;
+    function WeakSet3(iterable) {
+      "use strict";
+      all.set(this, new WeakMap2());
+      if (iterable)
+        iterable.forEach(this.add, this);
+    }
+  })(WeakMap);
+}
+var esm_default4 = self3.WeakSet;
+
+// node_modules/domconstants/esm/index.js
+var UID = "-" + Math.random().toFixed(6) + "%";
+var UID_IE = false;
+try {
+  if (!function(template, content, tabindex) {
+    return content in template && (template.innerHTML = "<p " + tabindex + '="' + UID + '"></p>', template[content].childNodes[0].getAttribute(tabindex) == UID);
+  }(document.createElement("template"), "content", "tabindex")) {
+    UID = "_dt: " + UID.slice(1, -1) + ";";
+    UID_IE = true;
+  }
+} catch (meh) {
+}
+var UIDC = "<!--" + UID + "-->";
+var COMMENT_NODE = 8;
+var DOCUMENT_FRAGMENT_NODE = 11;
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var SHOULD_USE_TEXT_CONTENT = /^(?:plaintext|script|style|textarea|title|xmp)$/i;
+var VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
+
+// node_modules/domsanitizer/esm/index.js
+function esm_default5(template) {
+  return template.join(UIDC).replace(selfClosing, fullClosing).replace(attrSeeker, attrReplacer);
+}
+var spaces = " \\f\\n\\r\\t";
+var almostEverything = "[^" + spaces + `\\/>"'=]+`;
+var attrName = "[" + spaces + "]+" + almostEverything;
+var tagName = "<([A-Za-z]+[A-Za-z0-9:._-]*)((?:";
+var attrPartials = `(?:\\s*=\\s*(?:'[^']*?'|"[^"]*?"|<[^>]*?>|` + almostEverything.replace("\\/", "") + "))?)";
+var attrSeeker = new RegExp(tagName + attrName + attrPartials + "+)([" + spaces + "]*/?>)", "g");
+var selfClosing = new RegExp(tagName + attrName + attrPartials + "*)([" + spaces + "]*/>)", "g");
+var findAttributes = new RegExp("(" + attrName + `\\s*=\\s*)(['"]?)` + UIDC + "\\2", "gi");
+function attrReplacer($0, $1, $2, $3) {
+  return "<" + $1 + $2.replace(findAttributes, replaceAttributes) + $3;
+}
+function replaceAttributes($0, $1, $2) {
+  return $1 + ($2 || '"') + UID + ($2 || '"');
+}
+function fullClosing($0, $1, $2) {
+  return VOID_ELEMENTS.test($1) ? $0 : "<" + $1 + $2 + "></" + $1 + ">";
+}
+
+// node_modules/uarray/esm/index.js
+var { isArray } = Array;
+var { indexOf, slice } = [];
+
+// node_modules/umap/esm/index.js
+var esm_default6 = (_) => ({
+  // About: get: _.get.bind(_)
+  // It looks like WebKit/Safari didn't optimize bind at all,
+  // so that using bind slows it down by 60%.
+  // Firefox and Chrome are just fine in both cases,
+  // so let's use the approach that works fast everywhere 👍
+  get: (key) => _.get(key),
+  set: (key, value) => (_.set(key, value), value)
+});
+
+// node_modules/uwire/esm/index.js
+var ELEMENT_NODE2 = 1;
+var nodeType = 111;
+var remove = ({ firstChild, lastChild }) => {
+  const range = document.createRange();
+  range.setStartAfter(firstChild);
+  range.setEndAfter(lastChild);
+  range.deleteContents();
+  return firstChild;
+};
+var diffable = (node, operation) => node.nodeType === nodeType ? 1 / operation < 0 ? operation ? remove(node) : node.lastChild : operation ? node.valueOf() : node.firstChild : node;
+var persistent = (fragment) => {
+  const { childNodes } = fragment;
+  const { length } = childNodes;
+  if (length < 2)
+    return length ? childNodes[0] : fragment;
+  const nodes = slice.call(childNodes, 0);
+  const firstChild = nodes[0];
+  const lastChild = nodes[length - 1];
+  return {
+    ELEMENT_NODE: ELEMENT_NODE2,
+    nodeType,
+    firstChild,
+    lastChild,
+    valueOf() {
+      if (childNodes.length !== length) {
+        let i = 0;
+        while (i < length)
+          fragment.appendChild(nodes[i++]);
+      }
+      return fragment;
+    }
+  };
+};
+
+// node_modules/@ungap/create-content/esm/index.js
+var createContent = function(document2) {
+  "use strict";
+  var FRAGMENT = "fragment";
+  var TEMPLATE = "template";
+  var HAS_CONTENT = "content" in create3(TEMPLATE);
+  var createHTML = HAS_CONTENT ? function(html3) {
+    var template = create3(TEMPLATE);
+    template.innerHTML = html3;
+    return template.content;
+  } : function(html3) {
+    var content = create3(FRAGMENT);
+    var template = create3(TEMPLATE);
+    var childNodes = null;
+    if (/^[^\S]*?<(col(?:group)?|t(?:head|body|foot|r|d|h))/i.test(html3)) {
+      var selector2 = RegExp.$1;
+      template.innerHTML = "<table>" + html3 + "</table>";
+      childNodes = template.querySelectorAll(selector2);
+    } else {
+      template.innerHTML = html3;
+      childNodes = template.childNodes;
+    }
+    append(content, childNodes);
+    return content;
+  };
+  return function createContent2(markup, type) {
+    return (type === "svg" ? createSVG : createHTML)(markup);
+  };
+  function append(root, childNodes) {
+    var length = childNodes.length;
+    while (length--)
+      root.appendChild(childNodes[0]);
+  }
+  function create3(element) {
+    return element === FRAGMENT ? document2.createDocumentFragment() : document2.createElementNS("http://www.w3.org/1999/xhtml", element);
+  }
+  function createSVG(svg3) {
+    var content = create3(FRAGMENT);
+    var template = create3("div");
+    template.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg">' + svg3 + "</svg>";
+    append(content, template.firstChild.childNodes);
+    return content;
+  }
+}(document);
+var esm_default7 = createContent;
+
+// node_modules/udomdiff/esm/index.js
+var esm_default8 = (parentNode, a, b, get, before) => {
+  const bLength = b.length;
+  let aEnd = a.length;
+  let bEnd = bLength;
+  let aStart = 0;
+  let bStart = 0;
+  let map = null;
+  while (aStart < aEnd || bStart < bEnd) {
+    if (aEnd === aStart) {
+      const node = bEnd < bLength ? bStart ? get(b[bStart - 1], -0).nextSibling : get(b[bEnd - bStart], 0) : before;
+      while (bStart < bEnd)
+        parentNode.insertBefore(get(b[bStart++], 1), node);
+    } else if (bEnd === bStart) {
+      while (aStart < aEnd) {
+        if (!map || !map.has(a[aStart]))
+          parentNode.removeChild(get(a[aStart], -1));
+        aStart++;
+      }
+    } else if (a[aStart] === b[bStart]) {
+      aStart++;
+      bStart++;
+    } else if (a[aEnd - 1] === b[bEnd - 1]) {
+      aEnd--;
+      bEnd--;
+    } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+      const node = get(a[--aEnd], -1).nextSibling;
+      parentNode.insertBefore(
+        get(b[bStart++], 1),
+        get(a[aStart++], -1).nextSibling
+      );
+      parentNode.insertBefore(get(b[--bEnd], 1), node);
+      a[aEnd] = b[bEnd];
+    } else {
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        let i = bStart;
+        while (i < bEnd)
+          map.set(b[i], i++);
+      }
+      if (map.has(a[aStart])) {
+        const index = map.get(a[aStart]);
+        if (bStart < index && index < bEnd) {
+          let i = aStart;
+          let sequence = 1;
+          while (++i < aEnd && i < bEnd && map.get(a[i]) === index + sequence)
+            sequence++;
+          if (sequence > index - bStart) {
+            const node = get(a[aStart], 0);
+            while (bStart < index)
+              parentNode.insertBefore(get(b[bStart++], 1), node);
+          } else {
+            parentNode.replaceChild(
+              get(b[bStart++], 1),
+              get(a[aStart++], -1)
+            );
+          }
+        } else
+          aStart++;
+      } else
+        parentNode.removeChild(get(a[aStart++], -1));
+    }
+  }
+  return b;
+};
+
+// node_modules/@ungap/import-node/esm/index.js
+var importNode = function(document2, appendChild, cloneNode, createTextNode, importNode2) {
+  var native = importNode2 in document2;
+  var fragment = document2.createDocumentFragment();
+  fragment[appendChild](document2[createTextNode]("g"));
+  fragment[appendChild](document2[createTextNode](""));
+  var content = native ? document2[importNode2](fragment, true) : fragment[cloneNode](true);
+  return content.childNodes.length < 2 ? function importNode3(node, deep) {
+    var clone = node[cloneNode]();
+    for (var childNodes = node.childNodes || [], length = childNodes.length, i = 0; deep && i < length; i++) {
+      clone[appendChild](importNode3(childNodes[i], deep));
+    }
+    return clone;
+  } : (
+    /* istanbul ignore next */
+    native ? document2[importNode2] : function(node, deep) {
+      return node[cloneNode](!!deep);
+    }
+  );
+}(
+  document,
+  "appendChild",
+  "cloneNode",
+  "createTextNode",
+  "importNode"
+);
+var esm_default9 = importNode;
+
+// node_modules/@ungap/trim/esm/index.js
+var trim = "".trim || /* istanbul ignore next */
+function() {
+  return String(this).replace(/^\s+|\s+/g, "");
+};
+var esm_default10 = trim;
+
+// node_modules/domtagger/esm/walker.js
+var normalizeAttributes = UID_IE ? function(attributes, parts) {
+  var html3 = parts.join(" ");
+  return parts.slice.call(attributes, 0).sort(function(left, right) {
+    return html3.indexOf(left.name) <= html3.indexOf(right.name) ? -1 : 1;
+  });
+} : function(attributes, parts) {
+  return parts.slice.call(attributes, 0);
+};
+function find(node, path) {
+  var length = path.length;
+  var i = 0;
+  while (i < length)
+    node = node.childNodes[path[i++]];
+  return node;
+}
+function parse(node, holes, parts, path) {
+  var childNodes = node.childNodes;
+  var length = childNodes.length;
+  var i = 0;
+  while (i < length) {
+    var child = childNodes[i];
+    switch (child.nodeType) {
+      case ELEMENT_NODE:
+        var childPath = path.concat(i);
+        parseAttributes(child, holes, parts, childPath);
+        parse(child, holes, parts, childPath);
+        break;
+      case COMMENT_NODE:
+        var textContent = child.textContent;
+        if (textContent === UID) {
+          parts.shift();
+          holes.push(
+            // basicHTML or other non standard engines
+            // might end up having comments in nodes
+            // where they shouldn't, hence this check.
+            SHOULD_USE_TEXT_CONTENT.test(node.nodeName) ? Text(node, path) : Any(child, path.concat(i))
+          );
+        } else {
+          switch (textContent.slice(0, 2)) {
+            case "/*":
+              if (textContent.slice(-2) !== "*/")
+                break;
+            case "\u{1F47B}":
+              node.removeChild(child);
+              i--;
+              length--;
+          }
+        }
+        break;
+      case TEXT_NODE:
+        if (SHOULD_USE_TEXT_CONTENT.test(node.nodeName) && esm_default10.call(child.textContent) === UIDC) {
+          parts.shift();
+          holes.push(Text(node, path));
+        }
+        break;
+    }
+    i++;
+  }
+}
+function parseAttributes(node, holes, parts, path) {
+  var attributes = node.attributes;
+  var cache2 = [];
+  var remove2 = [];
+  var array = normalizeAttributes(attributes, parts);
+  var length = array.length;
+  var i = 0;
+  while (i < length) {
+    var attribute2 = array[i++];
+    var direct = attribute2.value === UID;
+    var sparse;
+    if (direct || 1 < (sparse = attribute2.value.split(UIDC)).length) {
+      var name = attribute2.name;
+      if (cache2.indexOf(name) < 0) {
+        cache2.push(name);
+        var realName = parts.shift().replace(
+          direct ? /^(?:|[\S\s]*?\s)(\S+?)\s*=\s*('|")?$/ : new RegExp(
+            "^(?:|[\\S\\s]*?\\s)(" + name + `)\\s*=\\s*('|")[\\S\\s]*`,
+            "i"
+          ),
+          "$1"
+        );
+        var value = attributes[realName] || // the following ignore is covered by browsers
+        // while basicHTML is already case-sensitive
+        /* istanbul ignore next */
+        attributes[realName.toLowerCase()];
+        if (direct)
+          holes.push(Attr(value, path, realName, null));
+        else {
+          var skip = sparse.length - 2;
+          while (skip--)
+            parts.shift();
+          holes.push(Attr(value, path, realName, sparse));
+        }
+      }
+      remove2.push(attribute2);
+    }
+  }
+  length = remove2.length;
+  i = 0;
+  var cleanValue = 0 < length && UID_IE && !("ownerSVGElement" in node);
+  while (i < length) {
+    var attr = remove2[i++];
+    if (cleanValue)
+      attr.value = "";
+    node.removeAttribute(attr.name);
+  }
+  var nodeName = node.nodeName;
+  if (/^script$/i.test(nodeName)) {
+    var script = document.createElement(nodeName);
+    length = attributes.length;
+    i = 0;
+    while (i < length)
+      script.setAttributeNode(attributes[i++].cloneNode(true));
+    script.textContent = node.textContent;
+    node.parentNode.replaceChild(script, node);
+  }
+}
+function Any(node, path) {
+  return {
+    type: "any",
+    node,
+    path
+  };
+}
+function Attr(node, path, name, sparse) {
+  return {
+    type: "attr",
+    node,
+    path,
+    name,
+    sparse
+  };
+}
+function Text(node, path) {
+  return {
+    type: "text",
+    node,
+    path
+  };
+}
+
+// node_modules/domtagger/esm/index.js
+var esm_default11 = domtagger;
+var parsed = esm_default6(new esm_default());
+function createInfo(options, template) {
+  var markup = (options.convert || esm_default5)(template);
+  var transform = options.transform;
+  if (transform)
+    markup = transform(markup);
+  var content = esm_default7(markup, options.type);
+  cleanContent(content);
+  var holes = [];
+  parse(content, holes, template.slice(0), []);
+  return {
+    content,
+    updates: function(content2) {
+      var updates2 = [];
+      var len = holes.length;
+      var i = 0;
+      var off = 0;
+      while (i < len) {
+        var info2 = holes[i++];
+        var node = find(content2, info2.path);
+        switch (info2.type) {
+          case "any":
+            updates2.push({ fn: options.any(node, []), sparse: false });
+            break;
+          case "attr":
+            var sparse = info2.sparse;
+            var fn = options.attribute(node, info2.name, info2.node);
+            if (sparse === null)
+              updates2.push({ fn, sparse: false });
+            else {
+              off += sparse.length - 2;
+              updates2.push({ fn, sparse: true, values: sparse });
+            }
+            break;
+          case "text":
+            updates2.push({ fn: options.text(node), sparse: false });
+            node.textContent = "";
+            break;
+        }
+      }
+      len += off;
+      return function() {
+        var length = arguments.length;
+        if (len !== length - 1) {
+          throw new Error(
+            length - 1 + " values instead of " + len + "\n" + template.join("${value}")
+          );
+        }
+        var i2 = 1;
+        var off2 = 1;
+        while (i2 < length) {
+          var update2 = updates2[i2 - off2];
+          if (update2.sparse) {
+            var values = update2.values;
+            var value = values[0];
+            var j = 1;
+            var l = values.length;
+            off2 += l - 2;
+            while (j < l)
+              value += arguments[i2++] + values[j++];
+            update2.fn(value);
+          } else
+            update2.fn(arguments[i2++]);
+        }
+        return content2;
+      };
+    }
+  };
+}
+function createDetails(options, template) {
+  var info2 = parsed.get(template) || parsed.set(template, createInfo(options, template));
+  return info2.updates(esm_default9.call(document, info2.content, true));
+}
+var empty = [];
+function domtagger(options) {
+  var previous = empty;
+  var updates2 = cleanContent;
+  return function(template) {
+    if (previous !== template)
+      updates2 = createDetails(options, previous = template);
+    return updates2.apply(null, arguments);
+  };
+}
+function cleanContent(fragment) {
+  var childNodes = fragment.childNodes;
+  var i = childNodes.length;
+  while (i--) {
+    var child = childNodes[i];
+    if (child.nodeType !== 1 && esm_default10.call(child.textContent).length === 0) {
+      fragment.removeChild(child);
+    }
+  }
+}
+
+// node_modules/hyperhtml-style/esm/index.js
+var hyperStyle = function() {
+  "use strict";
+  var IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;
+  var hyphen = /([^A-Z])([A-Z]+)/g;
+  return function hyperStyle2(node, original) {
+    return "ownerSVGElement" in node ? svg3(node, original) : update2(node.style, false);
+  };
+  function ized($0, $1, $2) {
+    return $1 + "-" + $2.toLowerCase();
+  }
+  function svg3(node, original) {
+    var style;
+    if (original)
+      style = original.cloneNode(true);
+    else {
+      node.setAttribute("style", "--hyper:style;");
+      style = node.getAttributeNode("style");
+    }
+    style.value = "";
+    node.setAttributeNode(style);
+    return update2(style, true);
+  }
+  function toStyle(object) {
+    var key, css = [];
+    for (key in object)
+      css.push(key.replace(hyphen, ized), ":", object[key], ";");
+    return css.join("");
+  }
+  function update2(style, isSVG) {
+    var oldType, oldValue;
+    return function(newValue) {
+      var info2, key, styleValue, value;
+      switch (typeof newValue) {
+        case "object":
+          if (newValue) {
+            if (oldType === "object") {
+              if (!isSVG) {
+                if (oldValue !== newValue) {
+                  for (key in oldValue) {
+                    if (!(key in newValue)) {
+                      style[key] = "";
+                    }
+                  }
+                }
+              }
+            } else {
+              if (isSVG)
+                style.value = "";
+              else
+                style.cssText = "";
+            }
+            info2 = isSVG ? {} : style;
+            for (key in newValue) {
+              value = newValue[key];
+              styleValue = typeof value === "number" && !IS_NON_DIMENSIONAL.test(key) ? value + "px" : value;
+              if (!isSVG && /^--/.test(key))
+                info2.setProperty(key, styleValue);
+              else
+                info2[key] = styleValue;
+            }
+            oldType = "object";
+            if (isSVG)
+              style.value = toStyle(oldValue = info2);
+            else
+              oldValue = newValue;
+            break;
+          }
+        default:
+          if (oldValue != newValue) {
+            oldType = "string";
+            oldValue = newValue;
+            if (isSVG)
+              style.value = newValue || "";
+            else
+              style.cssText = newValue || "";
+          }
+          break;
+      }
+    };
+  }
+}();
+var esm_default12 = hyperStyle;
+
+// node_modules/uhandlers/esm/index.js
+var aria = (node) => (values) => {
+  for (const key in values) {
+    const name = key === "role" ? key : `aria-${key}`;
+    const value = values[key];
+    if (value == null)
+      node.removeAttribute(name);
+    else
+      node.setAttribute(name, value);
+  }
+};
+var attribute = (node, name) => {
+  let oldValue, orphan = true;
+  const attributeNode = document.createAttributeNS(null, name);
+  return (newValue) => {
+    if (oldValue !== newValue) {
+      oldValue = newValue;
+      if (oldValue == null) {
+        if (!orphan) {
+          node.removeAttributeNode(attributeNode);
+          orphan = true;
+        }
+      } else {
+        attributeNode.value = newValue;
+        if (orphan) {
+          node.setAttributeNodeNS(attributeNode);
+          orphan = false;
+        }
+      }
+    }
+  };
+};
+var boolean = (node, key, oldValue) => (newValue) => {
+  if (oldValue !== !!newValue) {
+    if (oldValue = !!newValue)
+      node.setAttribute(key, "");
+    else
+      node.removeAttribute(key);
+  }
+};
+var data = ({ dataset }) => (values) => {
+  for (const key in values) {
+    const value = values[key];
+    if (value == null)
+      delete dataset[key];
+    else
+      dataset[key] = value;
+  }
+};
+var event = (node, name) => {
+  let oldValue, type = name.slice(2);
+  if (!(name in node) && name.toLowerCase() in node)
+    type = type.toLowerCase();
+  return (newValue) => {
+    const info2 = isArray(newValue) ? newValue : [newValue, false];
+    if (oldValue !== info2[0]) {
+      if (oldValue)
+        node.removeEventListener(type, oldValue, info2[1]);
+      if (oldValue = info2[0])
+        node.addEventListener(type, oldValue, info2[1]);
+    }
+  };
+};
+var ref = (node) => (value) => {
+  if (typeof value === "function")
+    value(node);
+  else
+    value.current = node;
+};
+var setter = (node, key) => key === "dataset" ? data(node) : (value) => {
+  node[key] = value;
+};
+var text = (node) => {
+  let oldValue;
+  return (newValue) => {
+    if (oldValue != newValue) {
+      oldValue = newValue;
+      node.textContent = newValue == null ? "" : newValue;
+    }
+  };
+};
+
+// node_modules/lighterhtml/esm/tagger.js
+var hyperProperty = (node, name) => {
+  let oldValue;
+  return (newValue) => {
+    if (oldValue !== newValue) {
+      oldValue = newValue;
+      if (node[name] !== newValue) {
+        if (newValue == null) {
+          node[name] = "";
+          node.removeAttribute(name);
+        } else
+          node[name] = newValue;
+      }
+    }
+  };
+};
+var readOnly = /^(?:form|list)$/i;
+var text2 = (node, text3) => node.ownerDocument.createTextNode(text3);
+function Tagger(type) {
+  this.type = type;
+  return esm_default11(this);
+}
+;
+Tagger.prototype = {
+  // there are four kind of attributes, and related behavior:
+  //  * events, with a name starting with `on`, to add/remove event listeners
+  //  * special, with a name present in their inherited prototype, accessed directly
+  //  * regular, accessed through get/setAttribute standard DOM methods
+  //  * style, the only regular attribute that also accepts an object as value
+  //    so that you can style=${{width: 120}}. In this case, the behavior has been
+  //    fully inspired by Preact library and its simplicity.
+  attribute(node, name, original) {
+    const isSVG = this.type === "svg";
+    switch (name) {
+      case "class":
+        if (isSVG)
+          return attribute(node, name, isSVG);
+        name = "className";
+      case "props":
+        return setter(node, name);
+      case "aria":
+        return aria(node);
+      case "style":
+        return esm_default12(node, original, isSVG);
+      case "ref":
+        return ref(node);
+      case ".dataset":
+        return data(node);
+      default:
+        if (name.slice(0, 1) === ".")
+          return setter(node, name.slice(1));
+        if (name.slice(0, 1) === "?")
+          return boolean(node, name.slice(1));
+        if (name.slice(0, 2) === "on")
+          return event(node, name);
+        if (name in node && !(isSVG || readOnly.test(name)))
+          return hyperProperty(node, name);
+        return attribute(node, name, isSVG);
+    }
+  },
+  // in a hyper(node)`<div>${content}</div>` case
+  // everything could happen:
+  //  * it's a JS primitive, stored as text
+  //  * it's null or undefined, the node should be cleaned
+  //  * it's a promise, update the content once resolved
+  //  * it's an explicit intent, perform the desired operation
+  //  * it's an Array, resolve all values if Promises and/or
+  //    update the node with the resulting list of content
+  any(node, childNodes) {
+    const { type } = this;
+    let fastPath = false;
+    let oldValue;
+    const anyContent = (value) => {
+      switch (typeof value) {
+        case "string":
+        case "number":
+        case "boolean":
+          if (fastPath) {
+            if (oldValue !== value) {
+              oldValue = value;
+              childNodes[0].textContent = value;
+            }
+          } else {
+            fastPath = true;
+            oldValue = value;
+            childNodes = esm_default8(
+              node.parentNode,
+              childNodes,
+              [text2(node, value)],
+              diffable,
+              node
+            );
+          }
+          break;
+        case "function":
+          anyContent(value(node));
+          break;
+        case "object":
+        case "undefined":
+          if (value == null) {
+            fastPath = false;
+            childNodes = esm_default8(
+              node.parentNode,
+              childNodes,
+              [],
+              diffable,
+              node
+            );
+            break;
+          }
+        default:
+          fastPath = false;
+          oldValue = value;
+          if (isArray(value)) {
+            if (value.length === 0) {
+              if (childNodes.length) {
+                childNodes = esm_default8(
+                  node.parentNode,
+                  childNodes,
+                  [],
+                  diffable,
+                  node
+                );
+              }
+            } else {
+              switch (typeof value[0]) {
+                case "string":
+                case "number":
+                case "boolean":
+                  anyContent(String(value));
+                  break;
+                case "function":
+                  anyContent(value.map(invoke, node));
+                  break;
+                case "object":
+                  if (isArray(value[0])) {
+                    value = value.concat.apply([], value);
+                  }
+                default:
+                  childNodes = esm_default8(
+                    node.parentNode,
+                    childNodes,
+                    value,
+                    diffable,
+                    node
+                  );
+                  break;
+              }
+            }
+          } else if ("ELEMENT_NODE" in value) {
+            childNodes = esm_default8(
+              node.parentNode,
+              childNodes,
+              value.nodeType === 11 ? slice.call(value.childNodes) : [value],
+              diffable,
+              node
+            );
+          } else if ("text" in value) {
+            anyContent(String(value.text));
+          } else if ("any" in value) {
+            anyContent(value.any);
+          } else if ("html" in value) {
+            childNodes = esm_default8(
+              node.parentNode,
+              childNodes,
+              slice.call(
+                esm_default7(
+                  [].concat(value.html).join(""),
+                  type
+                ).childNodes
+              ),
+              diffable,
+              node
+            );
+          } else if ("length" in value) {
+            anyContent(slice.call(value));
+          }
+          break;
+      }
+    };
+    return anyContent;
+  },
+  // style or textareas don't accept HTML as content
+  // it's pointless to transform or analyze anything
+  // different from text there but it's worth checking
+  // for possible defined intents.
+  text(node) {
+    let oldValue;
+    const textContent = (value) => {
+      if (oldValue !== value) {
+        oldValue = value;
+        const type = typeof value;
+        if (type === "object" && value) {
+          if ("text" in value) {
+            textContent(String(value.text));
+          } else if ("any" in value) {
+            textContent(value.any);
+          } else if ("html" in value) {
+            textContent([].concat(value.html).join(""));
+          } else if ("length" in value) {
+            textContent(slice.call(value).join(""));
+          }
+        } else if (type === "function") {
+          textContent(value(node));
+        } else {
+          node.textContent = value == null ? "" : value;
+        }
+      }
+    };
+    return textContent;
+  }
+};
+function invoke(callback) {
+  return callback(this);
+}
+
+// node_modules/lighterhtml/esm/index.js
+var { create, freeze, keys } = Object;
+var tProto = Tagger.prototype;
+var cache = esm_default6(new esm_default());
+var createRender = (Tagger2) => ({
+  html: outer("html", Tagger2),
+  svg: outer("svg", Tagger2),
+  render(where, what) {
+    const hole = typeof what === "function" ? what() : what;
+    const info2 = cache.get(where) || cache.set(where, createCache());
+    const wire = hole instanceof LighterHole ? unroll(Tagger2, info2, hole) : hole;
+    if (wire !== info2.wire) {
+      info2.wire = wire;
+      where.textContent = "";
+      where.appendChild(wire.valueOf());
+    }
+    return where;
+  }
+});
+var createCache = () => ({ stack: [], entry: null, wire: null });
+var outer = (type, Tagger2) => {
+  const cache2 = esm_default6(new esm_default());
+  const fixed = (info2) => function() {
+    return unroll(Tagger2, info2, hole.apply(null, arguments));
+  };
+  hole.for = (ref3, id) => {
+    const memo = cache2.get(ref3) || cache2.set(ref3, create(null));
+    return memo[id] || (memo[id] = fixed(createCache()));
+  };
+  hole.node = function() {
+    return unroll(
+      Tagger2,
+      createCache(),
+      hole.apply(null, arguments)
+    ).valueOf();
+  };
+  return hole;
+  function hole() {
+    return new LighterHole(type, tta.apply(null, arguments));
+  }
+};
+var unroll = (Tagger2, info2, { type, template, values }) => {
+  const { length } = values;
+  unrollValues(Tagger2, info2, values, length);
+  let { entry } = info2;
+  if (!entry || (entry.template !== template || entry.type !== type)) {
+    const tag = new Tagger2(type);
+    info2.entry = entry = {
+      type,
+      template,
+      tag,
+      wire: persistent(tag(template, ...values))
+    };
+  } else
+    entry.tag(template, ...values);
+  return entry.wire;
+};
+var unrollValues = (Tagger2, { stack }, values, length) => {
+  for (let i = 0; i < length; i++) {
+    const hole = values[i];
+    if (hole instanceof Hole)
+      values[i] = unroll(
+        Tagger2,
+        stack[i] || (stack[i] = createCache()),
+        hole
+      );
+    else if (isArray(hole))
+      unrollValues(
+        Tagger2,
+        stack[i] || (stack[i] = createCache()),
+        hole,
+        hole.length
+      );
+    else
+      stack[i] = null;
+  }
+  if (length < stack.length)
+    stack.splice(length);
+};
+freeze(LighterHole);
+function LighterHole(type, args) {
+  this.type = type;
+  this.template = args.shift();
+  this.values = args;
+}
+;
+var Hole = LighterHole;
+var custom = (overrides) => {
+  const prototype = create(tProto);
+  keys(overrides).forEach((key) => {
+    prototype[key] = overrides[key](
+      prototype[key] || (key === "convert" ? esm_default5 : String)
+    );
+  });
+  CustomTagger.prototype = prototype;
+  return createRender(CustomTagger);
+  function CustomTagger() {
+    return Tagger.apply(this, arguments);
+  }
+};
+var { render, html, svg } = createRender(Tagger);
+function tta() {
+  let out = [], i = 0, { length } = arguments;
+  while (i < length)
+    out.push(arguments[i++]);
+  return out;
+}
+
+// node_modules/reraf/esm/index.js
+var compat = typeof cancelAnimationFrame === "function";
+var cAF = compat ? cancelAnimationFrame : clearTimeout;
+var rAF = compat ? requestAnimationFrame : setTimeout;
+function reraf(limit) {
+  var force, timer, callback, self4, args;
+  reset();
+  return function reschedule(_callback, _self, _args) {
+    callback = _callback;
+    self4 = _self;
+    args = _args;
+    if (!timer)
+      timer = rAF(invoke3);
+    if (--force < 0)
+      stop2(true);
+    return stop2;
+  };
+  function invoke3() {
+    reset();
+    callback.apply(self4, args || []);
+  }
+  function reset() {
+    force = limit || Infinity;
+    timer = compat ? 0 : null;
+  }
+  function stop2(flush) {
+    var didStop = !!timer;
+    if (didStop) {
+      cAF(timer);
+      if (flush)
+        invoke3();
+    }
+    return didStop;
+  }
+}
+;
+
+// node_modules/augmentor/esm/index.js
+var state = null;
+var augmentor = (fn) => {
+  const stack = [];
+  return function hook() {
+    const prev = state;
+    const after = [];
+    state = {
+      hook,
+      args: arguments,
+      stack,
+      i: 0,
+      length: stack.length,
+      after
+    };
+    try {
+      return fn.apply(null, arguments);
+    } finally {
+      state = prev;
+      for (let i = 0, { length } = after; i < length; i++)
+        after[i]();
+    }
+  };
+};
+var contextual = (fn) => {
+  let check = true;
+  let context = null;
+  const augmented2 = augmentor(function() {
+    return fn.apply(context, arguments);
+  });
+  return function hook() {
+    const result = augmented2.apply(context = this, arguments);
+    if (check) {
+      check = !check;
+      if (hasEffect(augmented2))
+        effects.set(hook, effects.get(augmented2));
+    }
+    return result;
+  };
+};
+var updates = esm_default6(/* @__PURE__ */ new WeakMap());
+var hookdate = (hook, ctx, args) => {
+  hook.apply(ctx, args);
+};
+var defaults = { async: false, always: false };
+var getValue = (value, f) => typeof f == "function" ? f(value) : f;
+var useReducer = (reducer, value, init2, options) => {
+  const i = state.i++;
+  const { hook, args, stack, length } = state;
+  if (i === length)
+    state.length = stack.push({});
+  const ref3 = stack[i];
+  ref3.args = args;
+  if (i === length) {
+    const fn = typeof init2 === "function";
+    const { async: asy, always } = (fn ? options : init2) || options || defaults;
+    ref3.$ = fn ? init2(value) : getValue(void 0, value);
+    ref3._ = asy ? updates.get(hook) || updates.set(hook, reraf()) : hookdate;
+    ref3.f = (value2) => {
+      const $value = reducer(ref3.$, value2);
+      if (always || ref3.$ !== $value) {
+        ref3.$ = $value;
+        ref3._(hook, null, ref3.args);
+      }
+    };
+  }
+  return [ref3.$, ref3.f];
+};
+var useState = (value, options) => useReducer(getValue, value, void 0, options);
+var hooks = /* @__PURE__ */ new WeakMap();
+var invoke2 = ({ hook, args }) => {
+  hook.apply(null, args);
+};
+var createContext = (value) => {
+  const context = { value, provide };
+  hooks.set(context, []);
+  return context;
+};
+var useContext = (context) => {
+  const { hook, args } = state;
+  const stack = hooks.get(context);
+  const info2 = { hook, args };
+  if (!stack.some(update, info2))
+    stack.push(info2);
+  return context.value;
+};
+function provide(value) {
+  if (this.value !== value) {
+    this.value = value;
+    hooks.get(this).forEach(invoke2);
+  }
+}
+function update({ hook }) {
+  return hook === this.hook;
+}
+var effects = /* @__PURE__ */ new WeakMap();
+var fx = esm_default6(effects);
+var stop = () => {
+};
+var createEffect = (asy) => (effect, guards) => {
+  const i = state.i++;
+  const { hook, after, stack, length } = state;
+  if (i < length) {
+    const info2 = stack[i];
+    const { update: update2, values, stop: stop2 } = info2;
+    if (!guards || guards.some(different, values)) {
+      info2.values = guards;
+      if (asy)
+        stop2(asy);
+      const { clean } = info2;
+      if (clean) {
+        info2.clean = null;
+        clean();
+      }
+      const invoke3 = () => {
+        info2.clean = effect();
+      };
+      if (asy)
+        update2(invoke3);
+      else
+        after.push(invoke3);
+    }
+  } else {
+    const update2 = asy ? reraf() : stop;
+    const info2 = { clean: null, update: update2, values: guards, stop };
+    state.length = stack.push(info2);
+    (fx.get(hook) || fx.set(hook, [])).push(info2);
+    const invoke3 = () => {
+      info2.clean = effect();
+    };
+    if (asy)
+      info2.stop = update2(invoke3);
+    else
+      after.push(invoke3);
+  }
+};
+var dropEffect = (hook) => {
+  (effects.get(hook) || []).forEach((info2) => {
+    const { clean, stop: stop2 } = info2;
+    stop2();
+    if (clean) {
+      info2.clean = null;
+      clean();
+    }
+  });
+};
+var hasEffect = effects.has.bind(effects);
+var useEffect = createEffect(true);
+var useLayoutEffect = createEffect(false);
+var useMemo = (memo, guards) => {
+  const i = state.i++;
+  const { stack, length } = state;
+  if (i === length)
+    state.length = stack.push({ $: memo(), _: guards });
+  else if (!guards || guards.some(different, stack[i]._))
+    stack[i] = { $: memo(), _: guards };
+  return stack[i].$;
+};
+var useCallback = (fn, guards) => useMemo(() => fn, guards);
+var useRef = (value) => {
+  const i = state.i++;
+  const { stack, length } = state;
+  if (i === length)
+    state.length = stack.push({ current: value });
+  return stack[i];
+};
+function different(value, i) {
+  return value !== this[i];
+}
+
+// node_modules/heresy/esm/utils.js
+var transpiled = null;
+try {
+  transpiled = new { o() {
+  } }.o();
+} catch ($) {
+}
+var extend = (Super) => class extends Super {
+};
+if (transpiled) {
+  const { getPrototypeOf, setPrototypeOf } = Object;
+  const { construct } = typeof Reflect === "object" ? Reflect : {
+    construct(Super, args, Target) {
+      const a = [null];
+      for (let i = 0; i < args.length; i++)
+        a.push(args[i]);
+      const Parent = Super.bind.apply(Super, a);
+      return setPrototypeOf(new Parent(), Target.prototype);
+    }
+  };
+  extend = function(Super, cutTheMiddleMan) {
+    function Class() {
+      return construct(
+        cutTheMiddleMan ? getPrototypeOf(Super) : Super,
+        arguments,
+        Class
+      );
+    }
+    setPrototypeOf(Class.prototype, Super.prototype);
+    return setPrototypeOf(Class, Super);
+  };
+}
+var hash = (s) => {
+  const { length } = s;
+  let t = 0;
+  let i = 0;
+  while (i < length) {
+    t = (t << 5) - t + s.charCodeAt(i++);
+    t = t & t;
+  }
+  return t.toString(36);
+};
+var registry = {
+  map: {},
+  re: null
+};
+var regExp = (keys3) => new RegExp(
+  `<(/)?(${keys3.join("|")})([^A-Za-z0-9:._-])`,
+  "g"
+);
+var tmp = null;
+var replace = (markup, info2) => {
+  const { map, re } = tmp || info2;
+  return markup.replace(re, (_, close, name, after) => {
+    const { tagName: tagName2, is, element } = map[name];
+    return element ? close ? `</${is}>` : `<${is}${after}` : close ? `</${tagName2}>` : `<${tagName2} is="${is}"${after}`;
+  });
+};
+var selector = ({ tagName: tagName2, is, element }) => element ? is : `${tagName2}[is="${is}"]`;
+var getInfo = () => tmp;
+var setInfo = (info2) => {
+  tmp = info2;
+};
+
+// node_modules/heresy/esm/augmented.js
+var hooks2 = {
+  useCallback,
+  useContext,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState
+};
+var {
+  render: lighterRender,
+  html: lighterHTML,
+  svg: lighterSVG
+} = custom({
+  transform: () => (markup) => replace(markup, registry)
+});
+var secret = "_\u{1F525}";
+var { defineProperties } = Object;
+var $html = new esm_default();
+var $svg = new esm_default();
+var $mappedAttributes = new esm_default();
+var ws = new esm_default4();
+var configurable = true;
+var attributeChangedCallback = "attributeChangedCallback";
+var connectedCallback = "connectedCallback";
+var disconnectedCallback = `dis${connectedCallback}`;
+var addInit = (prototype, properties, method) => {
+  if (method in prototype) {
+    const original = prototype[method];
+    properties[method] = {
+      configurable,
+      value() {
+        init.call(this);
+        return original.apply(this, arguments);
+      }
+    };
+  } else
+    properties[method] = {
+      configurable,
+      value: init
+    };
+};
+var augmented = (Class) => {
+  const { prototype } = Class;
+  const events = [];
+  const properties = {
+    html: {
+      configurable,
+      get: getHTML
+    },
+    svg: {
+      configurable,
+      get: getSVG
+    }
+  };
+  properties[secret] = {
+    value: {
+      events,
+      info: null
+    }
+  };
+  if (!("handleEvent" in prototype))
+    properties.handleEvent = {
+      configurable,
+      value: handleEvent
+    };
+  if ("render" in prototype && prototype.render.length) {
+    const { oninit } = prototype;
+    defineProperties(prototype, {
+      oninit: {
+        configurable,
+        value() {
+          const hook = augmentor(this.render.bind(this, hooks2));
+          defineProperties(this, {
+            render: {
+              configurable,
+              value: hook
+            }
+          });
+          this.addEventListener(
+            "disconnected",
+            dropEffect.bind(null, hook),
+            false
+          );
+          if (oninit)
+            oninit.apply(this, arguments);
+        }
+      }
+    });
+  }
+  if ("oninit" in prototype) {
+    events.push("init");
+    addInit(prototype, properties, "render");
+  }
+  addInit(prototype, properties, attributeChangedCallback);
+  addInit(prototype, properties, connectedCallback);
+  addInit(prototype, properties, disconnectedCallback);
+  [
+    [
+      attributeChangedCallback,
+      "onattributechanged",
+      onattributechanged
+    ],
+    [
+      connectedCallback,
+      "onconnected",
+      onconnected
+    ],
+    [
+      disconnectedCallback,
+      "ondisconnected",
+      ondisconnected
+    ],
+    [
+      connectedCallback,
+      "render",
+      onconnectedrender
+    ]
+  ].forEach(([ce, he, value]) => {
+    if (!(ce in prototype) && he in prototype) {
+      if (he !== "render")
+        events.push(he.slice(2));
+      if (ce in properties) {
+        const original = properties[ce].value;
+        properties[ce] = {
+          configurable,
+          value() {
+            original.apply(this, arguments);
+            return value.apply(this, arguments);
+          }
+        };
+      } else
+        properties[ce] = { configurable, value };
+    }
+  });
+  const booleanAttributes = Class.booleanAttributes || [];
+  booleanAttributes.forEach((name) => {
+    if (!(name in prototype))
+      properties[name] = {
+        configurable,
+        get() {
+          return this.hasAttribute(name);
+        },
+        set(value) {
+          if (!value || value === "false")
+            this.removeAttribute(name);
+          else
+            this.setAttribute(name, value);
+        }
+      };
+  });
+  const observedAttributes = Class.observedAttributes || [];
+  observedAttributes.forEach((name) => {
+    if (!(name in prototype))
+      properties[name] = {
+        configurable,
+        get() {
+          return this.getAttribute(name);
+        },
+        set(value) {
+          if (value == null)
+            this.removeAttribute(name);
+          else
+            this.setAttribute(name, value);
+        }
+      };
+  });
+  const mappedAttributes = Class.mappedAttributes || [];
+  mappedAttributes.forEach((name) => {
+    const _ = new esm_default();
+    const listening = "on" + name in prototype;
+    if (listening)
+      events.push(name);
+    properties[name] = {
+      configurable,
+      get() {
+        return _.get(this);
+      },
+      set(detail) {
+        _.set(this, detail);
+        if (listening) {
+          const e = evt(name);
+          e.detail = detail;
+          if (ws.has(this))
+            this.dispatchEvent(e);
+          else {
+            const dispatch = $mappedAttributes.get(this);
+            if (dispatch)
+              dispatch.push(e);
+            else
+              $mappedAttributes.set(this, [e]);
+          }
+        }
+      }
+    };
+  });
+  defineProperties(prototype, properties);
+  const attributes = booleanAttributes.concat(observedAttributes);
+  return attributes.length ? defineProperties(Class, {
+    observedAttributes: {
+      configurable,
+      get: () => attributes
+    }
+  }) : Class;
+};
+var defineHook = (name, hook) => {
+  if (name in hooks2)
+    throw new Error("duplicated hook " + name);
+  hooks2[name] = hook(hooks2);
+};
+var evt = (type) => new esm_default3(type);
+var html2 = (...args) => new Hole("html", args);
+html2.for = lighterHTML.for;
+var svg2 = (...args) => new Hole("svg", args);
+svg2.for = lighterSVG.for;
+var setParsed = (wm, template, { info: info2 }) => {
+  const value = info2 ? replace(template.join(secret), info2).split(secret) : template;
+  wm.set(template, value);
+  return value;
+};
+var setWrap = (self4, type, wm) => {
+  const fn = wrap(self4, type, new esm_default());
+  wm.set(self4, fn);
+  return fn;
+};
+var wrap = (self4, type, wm) => (template, ...values) => {
+  const local = wm.get(template) || setParsed(wm, template, self4[secret]);
+  return lighterRender(self4, () => type(local, ...values));
+};
+function addListener(type) {
+  this.addEventListener(type, this);
+}
+function dispatchEvent(event2) {
+  this.dispatchEvent(event2);
+}
+function getHTML() {
+  return $html.get(this) || setWrap(this, html2, $html);
+}
+function getSVG() {
+  return $svg.get(this) || setWrap(this, svg2, $svg);
+}
+function handleEvent(event2) {
+  this[`on${event2.type}`](event2);
+}
+function init() {
+  if (!ws.has(this)) {
+    ws.add(this);
+    this[secret].events.forEach(addListener, this);
+    this.dispatchEvent(evt("init"));
+    const events = $mappedAttributes.get(this);
+    if (events) {
+      $mappedAttributes.delete(this);
+      events.forEach(dispatchEvent, this);
+    }
+  }
+}
+function onattributechanged(attributeName, oldValue, newValue) {
+  const event2 = evt("attributechanged");
+  event2.attributeName = attributeName;
+  event2.oldValue = oldValue;
+  event2.newValue = newValue;
+  this.dispatchEvent(event2);
+}
+function onconnected() {
+  this.dispatchEvent(evt("connected"));
+}
+function onconnectedrender() {
+  this.render();
+}
+function ondisconnected() {
+  this.dispatchEvent(evt("disconnected"));
+}
+
+// node_modules/heresy/esm/index.js
+var {
+  create: create2,
+  defineProperty,
+  defineProperties: defineProperties2,
+  getOwnPropertyNames,
+  getOwnPropertySymbols,
+  getOwnPropertyDescriptor,
+  keys: keys2
+} = Object;
+var HTML = {
+  element: HTMLElement
+};
+var cc = new esm_default();
+var dc = new esm_default();
+var oc = new esm_default();
+var fragments = new esm_default();
+var info = (tagName2, is) => ({ tagName: tagName2, is, element: tagName2 === "element" });
+var define = ($, definition) => (typeof $ === "string" ? register($, definition, "") : register($.name, $, "")).Class;
+var fromClass = (constructor) => {
+  const Class = extend(constructor, false);
+  cc.set(constructor, augmented(Class));
+  return Class;
+};
+var fromObject = (object, tag) => {
+  const { statics, prototype } = grabInfo(object);
+  const Class = extend(
+    HTML[tag] || (HTML[tag] = document.createElement(tag).constructor),
+    false
+  );
+  defineProperties2(Class.prototype, prototype);
+  defineProperties2(Class, statics);
+  oc.set(object, augmented(Class));
+  return Class;
+};
+var grabInfo = (object) => {
+  const statics = create2(null);
+  const prototype = create2(null);
+  const info2 = { prototype, statics };
+  getOwnPropertyNames(object).concat(
+    getOwnPropertySymbols(object)
+  ).forEach((name) => {
+    const descriptor = getOwnPropertyDescriptor(object, name);
+    descriptor.enumerable = false;
+    switch (name) {
+      case "extends":
+        name = "tagName";
+      case "contains":
+      case "includes":
+      case "name":
+      case "booleanAttributes":
+      case "mappedAttributes":
+      case "observedAttributes":
+      case "style":
+      case "tagName":
+        statics[name] = descriptor;
+        break;
+      default:
+        prototype[name] = descriptor;
+    }
+  });
+  return info2;
+};
+var injectStyle = (cssText) => {
+  if ((cssText || "").length) {
+    const style = document.createElement("style");
+    style.type = "text/css";
+    if (style.styleSheet)
+      style.styleSheet.cssText = cssText;
+    else
+      style.appendChild(document.createTextNode(cssText));
+    const head = document.head || document.querySelector("head");
+    head.insertBefore(style, head.lastChild);
+  }
+};
+var ref2 = (self4, name) => self4 ? self4[name] || (self4[name] = { current: null }) : { current: null };
+var register = ($, definition, uid) => {
+  const validName = /^([A-Z][A-Za-z0-9_]*)(<([A-Za-z0-9:._-]+)>|:([A-Za-z0-9:._-]+))?$/;
+  if (!validName.test($))
+    throw "Invalid name";
+  const { $1: name, $3: asTag, $4: asColon } = RegExp;
+  let tagName2 = asTag || asColon || definition.tagName || definition.extends || "element";
+  const isFragment = tagName2 === "fragment";
+  if (isFragment)
+    tagName2 = "element";
+  else if (!/^[A-Za-z0-9:._-]+$/.test(tagName2))
+    throw "Invalid tag";
+  let hyphenizedName = "";
+  let suffix = "";
+  if (tagName2.indexOf("-") < 0) {
+    hyphenizedName = esm_default2(name) + uid;
+    if (hyphenizedName.indexOf("-") < 0)
+      suffix = "-heresy";
+  } else {
+    hyphenizedName = tagName2 + uid;
+    tagName2 = "element";
+  }
+  const is = hyphenizedName + suffix;
+  if (customElements.get(is))
+    throw `Duplicated ${is} definition`;
+  const Class = extend(
+    typeof definition === "object" ? oc.get(definition) || fromObject(definition, tagName2) : cc.get(definition) || fromClass(definition),
+    true
+  );
+  const element = tagName2 === "element";
+  defineProperty(Class, "new", {
+    value: element ? () => document.createElement(is) : () => document.createElement(tagName2, { is })
+  });
+  defineProperty(Class.prototype, "is", { value: is });
+  if (uid === "") {
+    const id = hash(hyphenizedName.toUpperCase());
+    registry.map[name] = setupIncludes(Class, tagName2, is, { id, i: 0 });
+    registry.re = regExp(keys2(registry.map));
+  }
+  if (isFragment) {
+    const { render: render3 } = Class.prototype;
+    defineProperty(
+      Class.prototype,
+      "render",
+      {
+        configurable: true,
+        value() {
+          if (render3)
+            render3.apply(this, arguments);
+          if (this.parentNode) {
+            const { firstChild } = this;
+            let contents = null;
+            if (firstChild) {
+              const range = document.createRange();
+              range.setStartBefore(firstChild);
+              range.setEndAfter(this.lastChild);
+              contents = range.extractContents();
+              this.parentNode.replaceChild(contents, this);
+            }
+          }
+        }
+      }
+    );
+  }
+  const args = [is, Class];
+  if (!element)
+    args.push({ extends: tagName2 });
+  customElements.define(...args);
+  return { Class, is, name, tagName: tagName2 };
+};
+var render2 = (where, what) => lighterRender(
+  where,
+  typeof what === "function" ? what : what instanceof Hole ? () => what : runtime(what)
+);
+var dcid = Math.random();
+var runtime = (Component) => {
+  let Class = dc.get(Component);
+  if (!Class) {
+    const name = ("Heresy" + ++dcid).replace(/[^He-y0-9]/g, "");
+    dc.set(Component, Class = define(name, Component));
+  }
+  return () => Class.new();
+};
+var setupIncludes = (Class, tagName2, is, u) => {
+  const { prototype } = Class;
+  const details = info(tagName2, is);
+  const styles = [selector(details)];
+  const includes = Class.includes || Class.contains;
+  if (includes) {
+    const map = {};
+    keys2(includes).forEach(($) => {
+      const uid = `-${u.id}-${u.i++}`;
+      const { Class: Class2, is: is2, name, tagName: tagName3 } = register($, includes[$], uid);
+      styles.push(selector(map[name] = setupIncludes(Class2, tagName3, is2, u)));
+    });
+    const re = regExp(keys2(map));
+    const { events } = prototype[secret];
+    const value = {
+      events,
+      info: { map, re }
+    };
+    defineProperty(prototype, secret, { value });
+    if ("render" in prototype) {
+      const { render: render3 } = prototype;
+      const { info: info2 } = value;
+      defineProperty(prototype, "render", {
+        configurable: true,
+        value() {
+          const tmp2 = getInfo();
+          setInfo(info2);
+          const out = render3.apply(this, arguments);
+          setInfo(tmp2);
+          return out;
+        }
+      });
+    }
+  }
+  if ("style" in Class)
+    injectStyle(Class.style(...styles));
+  return details;
+};
+
+// src/lib/version.ts
+var sdkVersion = "2.0.0-beta2";
+
+// src/lib/embed/index.ts
+var boolAttrs = [
+  "audio",
+  "background",
+  "cameraaccess",
+  "chat",
+  "people",
+  "embed",
+  "emptyRoomInvitation",
+  "help",
+  "leaveButton",
+  "precallReview",
+  "screenshare",
+  "video",
+  "floatSelf",
+  "recording",
+  "logo",
+  "locking",
+  "participantCount",
+  "settingsButton",
+  "pipButton",
+  "moreButton",
+  "personality",
+  "subgridLabels",
+  "lowData",
+  "breakout"
+];
+define("WherebyEmbed", {
+  oninit() {
+    this.iframe = ref2();
+  },
+  onconnected() {
+    window.addEventListener("message", this.onmessage.bind(this));
+  },
+  ondisconnected() {
+    window.removeEventListener("message", this.onmessage.bind(this));
+  },
+  observedAttributes: [
+    "displayName",
+    "minimal",
+    "room",
+    "subdomain",
+    "lang",
+    "metadata",
+    "groups",
+    "virtualBackgroundUrl",
+    "avatarUrl",
+    "externalId",
+    ...boolAttrs
+  ].map((a) => a.toLowerCase()),
+  onattributechanged({ attributeName, oldValue }) {
+    if (["room", "subdomain"].includes(attributeName) && oldValue == null)
+      return;
+    this.render();
+  },
+  style(self4) {
+    return `
+    ${self4} {
+      display: block;
+    }
+    ${self4} iframe {
+      border: none;
+      height: 100%;
+      width: 100%;
+    }
+    `;
+  },
+  // Commands
+  _postCommand(command, args = []) {
+    if (this.iframe.current) {
+      this.iframe.current.contentWindow.postMessage({ command, args }, this.url.origin);
+    }
+  },
+  startRecording() {
+    this._postCommand("start_recording");
+  },
+  stopRecording() {
+    this._postCommand("stop_recording");
+  },
+  toggleCamera(enabled) {
+    this._postCommand("toggle_camera", [enabled]);
+  },
+  toggleMicrophone(enabled) {
+    this._postCommand("toggle_microphone", [enabled]);
+  },
+  toggleScreenshare(enabled) {
+    this._postCommand("toggle_screenshare", [enabled]);
+  },
+  onmessage({ origin, data: data2 }) {
+    if (origin !== this.url.origin)
+      return;
+    const { type, payload: detail } = data2;
+    this.dispatchEvent(new CustomEvent(type, { detail }));
+  },
+  render() {
+    const {
+      avatarurl: avatarUrl,
+      displayname: displayName,
+      externalId,
+      lang,
+      metadata,
+      minimal,
+      room,
+      groups,
+      virtualbackgroundurl: virtualBackgroundUrl
+    } = this;
+    if (!room)
+      return this.html`Whereby: Missing room attribute.`;
+    const m = /https:\/\/([^.]+)(\.whereby.com|-ip-\d+-\d+-\d+-\d+.hereby.dev:4443)\/.+/.exec(room);
+    const subdomain = m && m[1] || this.subdomain;
+    if (!subdomain)
+      return this.html`Whereby: Missing subdomain attr.`;
+    if (!m) {
+      return this.html`could not parse URL.`;
+    }
+    const baseURL = m[2] || `.whereby.com`;
+    this.url = new URL(room, `https://${subdomain}${baseURL}`);
+    const roomUrl = new URL(room);
+    if (roomUrl.searchParams.get("roomKey")) {
+      this.url.searchParams.append("roomKey", roomUrl.searchParams.get("roomKey"));
+    }
+    Object.entries(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+      jsApi: true,
+      we: "2.0.0-beta2",
+      iframeSource: subdomain
+    }, displayName && { displayName }), lang && { lang }), metadata && { metadata }), externalId && { externalId }), groups && { groups }), virtualBackgroundUrl && { virtualBackgroundUrl }), avatarUrl && { avatarUrl }), minimal != null && { embed: minimal }), boolAttrs.reduce(
+      // add to URL if set in any way
+      (o, v) => this[v.toLowerCase()] != null ? __spreadProps(__spreadValues({}, o), { [v]: this[v.toLowerCase()] }) : o,
+      {}
+    ))).forEach(([k, v]) => {
+      if (!this.url.searchParams.has(k) && typeof v === "string") {
+        this.url.searchParams.set(k, v);
+      }
+    });
+    return this.html`
+        <iframe
+            ref=${this.iframe}
+            src=${this.url}
+            allow="autoplay; camera; microphone; fullscreen; speaker; display-capture" />
+        `;
+  }
+});
+export {
+  sdkVersion
+};
+/*! Bundled license information:
+
+@ungap/weakmap/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+@ungap/event/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+@ungap/weakset/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+domconstants/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+domsanitizer/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+@ungap/create-content/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+@ungap/import-node/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+hyperhtml-style/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+
+augmentor/esm/index.js:
+  (*! (c) Andrea Giammarchi - ISC *)
+*/