(function(f){if(typeof exports===“object”&&typeof module!==“undefined”){module.exports=f()}else if(typeof define===“function”&&define.amd){define([],f)}else{var g;if(typeof window!==“undefined”){g=window}else if(typeof global!==“undefined”){g=global}else if(typeof self!==“undefined”){g=self}else{g=this}g.snabbdom = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n){if(!e){var c=“function”==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(“Cannot find module '”i“'”);throw a.code=“MODULE_NOT_FOUND”,a}var p=n={exports:{}};e[0].call(p.exports,function®{var n=e[1];return o(n||r)},p,p.exports,r,e,n,t)}return n.exports}for(var u=“function”==typeof require&&require,i=0;i);return o}return r})()({1:[function(require,module,exports){ “use strict”;

var _init = require(“./node_modules/snabbdom/build/init”);

var _h = require(“./node_modules/snabbdom/build/h”);

var _tovnode = require(“./node_modules/snabbdom/build/tovnode”);

var _attributes = require(“./node_modules/snabbdom/build/modules/attributes”);

var _class = require(“./node_modules/snabbdom/build/modules/class”);

var _dataset = require(“./node_modules/snabbdom/build/modules/dataset”);

var _eventlisteners = require(“./node_modules/snabbdom/build/modules/eventlisteners”);

var _props = require(“./node_modules/snabbdom/build/modules/props”);

var _style = require(“./node_modules/snabbdom/build/modules/style”);

// browserify build.js -p esmify -s snabbdom > opal/vendor/snabbdom.js module.exports.init = _init.init; module.exports.h = _h.h; module.exports.toVNode = _tovnode.toVNode; module.exports.attributesModule = _attributes.attributesModule; module.exports.classModule = _class.classModule; module.exports.datasetModule = _dataset.datasetModule; module.exports.eventListenersModule = _eventlisteners.eventListenersModule; module.exports.propsModule = _props.propsModule; module.exports.styleModule = _style.styleModule;

},{“./node_modules/snabbdom/build/h”:2,“./node_modules/snabbdom/build/init”:4,“./node_modules/snabbdom/build/modules/attributes”:6,“./node_modules/snabbdom/build/modules/class”:7,“./node_modules/snabbdom/build/modules/dataset”:8,“./node_modules/snabbdom/build/modules/eventlisteners”:9,“./node_modules/snabbdom/build/modules/props”:10,“./node_modules/snabbdom/build/modules/style”:11,“./node_modules/snabbdom/build/tovnode”:12}],2:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.h = h;

var _vnode = require(“./vnode”);

var is = _interopRequireWildcard(require(“./is”));

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== “function”) return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== “object” && typeof obj !== “function”) { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== “default” && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function addNS(data, children, sel) {

data.ns = "http://www.w3.org/2000/svg";

if (sel !== "foreignObject" && children !== undefined) {
  for (let i = 0; i < children.length; ++i) {
    const childData = children[i].data;

    if (childData !== undefined) {
      addNS(childData, children[i].children, children[i].sel);
    }
  }
}

}

function h(sel, b, c) {

let data = {};
let children;
let text;
let i;

if (c !== undefined) {
  if (b !== null) {
    data = b;
  }

  if (is.array(c)) {
    children = c;
  } else if (is.primitive(c)) {
    text = c.toString();
  } else if (c && c.sel) {
    children = [c];
  }
} else if (b !== undefined && b !== null) {
  if (is.array(b)) {
    children = b;
  } else if (is.primitive(b)) {
    text = b.toString();
  } else if (b && b.sel) {
    children = [b];
  } else {
    data = b;
  }
}

if (children !== undefined) {
  for (i = 0; i < children.length; ++i) {
    if (is.primitive(children[i])) children[i] = (0, _vnode.vnode)(undefined, undefined, undefined, children[i], undefined);
  }
}

if (sel[0] === "s" && sel[1] === "v" && sel[2] === "g" && (sel.length === 3 || sel[3] === "." || sel[3] === "#")) {
  addNS(data, children, sel);
}

return (0, _vnode.vnode)(sel, data, children, text, undefined);

}

},{“./is”:5,“./vnode”:13}],3:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.htmlDomApi = void 0;

function createElement(tagName, options) {

return document.createElement(tagName, options);

}

function createElementNS(namespaceURI, qualifiedName, options) {

return document.createElementNS(namespaceURI, qualifiedName, options);

}

function createTextNode(text) {

return document.createTextNode(text);

}

function createComment(text) {

return document.createComment(text);

}

function insertBefore(parentNode, newNode, referenceNode) {

parentNode.insertBefore(newNode, referenceNode);

}

function removeChild(node, child) {

node.removeChild(child);

}

function appendChild(node, child) {

node.appendChild(child);

}

function parentNode(node) {

return node.parentNode;

}

function nextSibling(node) {

return node.nextSibling;

}

function tagName(elm) {

return elm.tagName;

}

function setTextContent(node, text) {

node.textContent = text;

}

function getTextContent(node) {

return node.textContent;

}

function isElement(node) {

return node.nodeType === 1;

}

function isText(node) {

return node.nodeType === 3;

}

function isComment(node) {

return node.nodeType === 8;

}

const htmlDomApi = {

createElement,
createElementNS,
createTextNode,
createComment,
insertBefore,
removeChild,
appendChild,
parentNode,
nextSibling,
tagName,
setTextContent,
getTextContent,
isElement,
isText,
isComment

}; exports.htmlDomApi = htmlDomApi;

},{}],4:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.init = init;

var _vnode = require(“./vnode”);

var is = _interopRequireWildcard(require(“./is”));

var _htmldomapi = require(“./htmldomapi”);

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== “function”) return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== “object” && typeof obj !== “function”) { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== “default” && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function isUndef(s) {

return s === undefined;

}

function isDef(s) {

return s !== undefined;

}

const emptyNode = (0, _vnode.vnode)(“”, {}, [], undefined, undefined);

function sameVnode(vnode1, vnode2) {

var _a, _b;

const isSameKey = vnode1.key === vnode2.key;
const isSameIs = ((_a = vnode1.data) === null || _a === void 0 ? void 0 : _a.is) === ((_b = vnode2.data) === null || _b === void 0 ? void 0 : _b.is);
const isSameSel = vnode1.sel === vnode2.sel;
return isSameSel && isSameKey && isSameIs;

}

function isVnode(vnode) {

return vnode.sel !== undefined;

}

function createKeyToOldIdx(children, beginIdx, endIdx) {

var _a;

const map = {};

for (let i = beginIdx; i <= endIdx; ++i) {
  const key = (_a = children[i]) === null || _a === void 0 ? void 0 : _a.key;

  if (key !== undefined) {
    map[key] = i;
  }
}

return map;

}

const hooks = [“create”, “update”, “remove”, “destroy”, “pre”, “post”];

function init(modules, domApi) {

const cbs = {
  create: [],
  update: [],
  remove: [],
  destroy: [],
  pre: [],
  post: []
};
const api = domApi !== undefined ? domApi : _htmldomapi.htmlDomApi;

for (const hook of hooks) {
  for (const module of modules) {
    const currentHook = module[hook];

    if (currentHook !== undefined) {
      cbs[hook].push(currentHook);
    }
  }
}

function emptyNodeAt(elm) {
  const id = elm.id ? "#" + elm.id : ""; // elm.className doesn't return a string when elm is an SVG element inside a shadowRoot.
  // https://stackoverflow.com/questions/29454340/detecting-classname-of-svganimatedstring

  const classes = elm.getAttribute("class");
  const c = classes ? "." + classes.split(" ").join(".") : "";
  return (0, _vnode.vnode)(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);
}

function createRmCb(childElm, listeners) {
  return function rmCb() {
    if (--listeners === 0) {
      const parent = api.parentNode(childElm);
      api.removeChild(parent, childElm);
    }
  };
}

function createElm(vnode, insertedVnodeQueue) {
  var _a, _b;

  let i;
  let data = vnode.data;

  if (data !== undefined) {
    const init = (_a = data.hook) === null || _a === void 0 ? void 0 : _a.init;

    if (isDef(init)) {
      init(vnode);
      data = vnode.data;
    }
  }

  const children = vnode.children;
  const sel = vnode.sel;

  if (sel === "!") {
    if (isUndef(vnode.text)) {
      vnode.text = "";
    }

    vnode.elm = api.createComment(vnode.text);
  } else if (sel !== undefined) {
    // Parse selector
    const hashIdx = sel.indexOf("#");
    const dotIdx = sel.indexOf(".", hashIdx);
    const hash = hashIdx > 0 ? hashIdx : sel.length;
    const dot = dotIdx > 0 ? dotIdx : sel.length;
    const tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;
    const elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag, data) : api.createElement(tag, data);
    if (hash < dot) elm.setAttribute("id", sel.slice(hash + 1, dot));
    if (dotIdx > 0) elm.setAttribute("class", sel.slice(dot + 1).replace(/\./g, " "));

    for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);

    if (is.array(children)) {
      for (i = 0; i < children.length; ++i) {
        const ch = children[i];

        if (ch != null) {
          api.appendChild(elm, createElm(ch, insertedVnodeQueue));
        }
      }
    } else if (is.primitive(vnode.text)) {
      api.appendChild(elm, api.createTextNode(vnode.text));
    }

    const hook = vnode.data.hook;

    if (isDef(hook)) {
      (_b = hook.create) === null || _b === void 0 ? void 0 : _b.call(hook, emptyNode, vnode);

      if (hook.insert) {
        insertedVnodeQueue.push(vnode);
      }
    }
  } else {
    vnode.elm = api.createTextNode(vnode.text);
  }

  return vnode.elm;
}

function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {
  for (; startIdx <= endIdx; ++startIdx) {
    const ch = vnodes[startIdx];

    if (ch != null) {
      api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);
    }
  }
}

function invokeDestroyHook(vnode) {
  var _a, _b;

  const data = vnode.data;

  if (data !== undefined) {
    (_b = (_a = data === null || data === void 0 ? void 0 : data.hook) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a, vnode);

    for (let i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);

    if (vnode.children !== undefined) {
      for (let j = 0; j < vnode.children.length; ++j) {
        const child = vnode.children[j];

        if (child != null && typeof child !== "string") {
          invokeDestroyHook(child);
        }
      }
    }
  }
}

function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
  var _a, _b;

  for (; startIdx <= endIdx; ++startIdx) {
    let listeners;
    let rm;
    const ch = vnodes[startIdx];

    if (ch != null) {
      if (isDef(ch.sel)) {
        invokeDestroyHook(ch);
        listeners = cbs.remove.length + 1;
        rm = createRmCb(ch.elm, listeners);

        for (let i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);

        const removeHook = (_b = (_a = ch === null || ch === void 0 ? void 0 : ch.data) === null || _a === void 0 ? void 0 : _a.hook) === null || _b === void 0 ? void 0 : _b.remove;

        if (isDef(removeHook)) {
          removeHook(ch, rm);
        } else {
          rm();
        }
      } else {
        // Text node
        api.removeChild(parentElm, ch.elm);
      }
    }
  }
}

function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {
  let oldStartIdx = 0;
  let newStartIdx = 0;
  let oldEndIdx = oldCh.length - 1;
  let oldStartVnode = oldCh[0];
  let oldEndVnode = oldCh[oldEndIdx];
  let newEndIdx = newCh.length - 1;
  let newStartVnode = newCh[0];
  let newEndVnode = newCh[newEndIdx];
  let oldKeyToIdx;
  let idxInOld;
  let elmToMove;
  let before;

  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
    if (oldStartVnode == null) {
      oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
    } else if (oldEndVnode == null) {
      oldEndVnode = oldCh[--oldEndIdx];
    } else if (newStartVnode == null) {
      newStartVnode = newCh[++newStartIdx];
    } else if (newEndVnode == null) {
      newEndVnode = newCh[--newEndIdx];
    } else if (sameVnode(oldStartVnode, newStartVnode)) {
      patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
      oldStartVnode = oldCh[++oldStartIdx];
      newStartVnode = newCh[++newStartIdx];
    } else if (sameVnode(oldEndVnode, newEndVnode)) {
      patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
      oldEndVnode = oldCh[--oldEndIdx];
      newEndVnode = newCh[--newEndIdx];
    } else if (sameVnode(oldStartVnode, newEndVnode)) {
      // Vnode moved right
      patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
      api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));
      oldStartVnode = oldCh[++oldStartIdx];
      newEndVnode = newCh[--newEndIdx];
    } else if (sameVnode(oldEndVnode, newStartVnode)) {
      // Vnode moved left
      patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
      api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
      oldEndVnode = oldCh[--oldEndIdx];
      newStartVnode = newCh[++newStartIdx];
    } else {
      if (oldKeyToIdx === undefined) {
        oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
      }

      idxInOld = oldKeyToIdx[newStartVnode.key];

      if (isUndef(idxInOld)) {
        // New element
        api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
      } else {
        elmToMove = oldCh[idxInOld];

        if (elmToMove.sel !== newStartVnode.sel) {
          api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
        } else {
          patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
          oldCh[idxInOld] = undefined;
          api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
        }
      }

      newStartVnode = newCh[++newStartIdx];
    }
  }

  if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
    if (oldStartIdx > oldEndIdx) {
      before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
    } else {
      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
    }
  }
}

function patchVnode(oldVnode, vnode, insertedVnodeQueue) {
  var _a, _b, _c, _d, _e;

  const hook = (_a = vnode.data) === null || _a === void 0 ? void 0 : _a.hook;
  (_b = hook === null || hook === void 0 ? void 0 : hook.prepatch) === null || _b === void 0 ? void 0 : _b.call(hook, oldVnode, vnode);
  const elm = vnode.elm = oldVnode.elm;
  const oldCh = oldVnode.children;
  const ch = vnode.children;
  if (oldVnode === vnode) return;

  if (vnode.data !== undefined) {
    for (let i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);

    (_d = (_c = vnode.data.hook) === null || _c === void 0 ? void 0 : _c.update) === null || _d === void 0 ? void 0 : _d.call(_c, oldVnode, vnode);
  }

  if (isUndef(vnode.text)) {
    if (isDef(oldCh) && isDef(ch)) {
      if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue);
    } else if (isDef(ch)) {
      if (isDef(oldVnode.text)) api.setTextContent(elm, "");
      addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
    } else if (isDef(oldCh)) {
      removeVnodes(elm, oldCh, 0, oldCh.length - 1);
    } else if (isDef(oldVnode.text)) {
      api.setTextContent(elm, "");
    }
  } else if (oldVnode.text !== vnode.text) {
    if (isDef(oldCh)) {
      removeVnodes(elm, oldCh, 0, oldCh.length - 1);
    }

    api.setTextContent(elm, vnode.text);
  }

  (_e = hook === null || hook === void 0 ? void 0 : hook.postpatch) === null || _e === void 0 ? void 0 : _e.call(hook, oldVnode, vnode);
}

return function patch(oldVnode, vnode) {
  let i, elm, parent;
  const insertedVnodeQueue = [];

  for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();

  if (!isVnode(oldVnode)) {
    oldVnode = emptyNodeAt(oldVnode);
  }

  if (sameVnode(oldVnode, vnode)) {
    patchVnode(oldVnode, vnode, insertedVnodeQueue);
  } else {
    elm = oldVnode.elm;
    parent = api.parentNode(elm);
    createElm(vnode, insertedVnodeQueue);

    if (parent !== null) {
      api.insertBefore(parent, vnode.elm, api.nextSibling(elm));
      removeVnodes(parent, [oldVnode], 0, 0);
    }
  }

  for (i = 0; i < insertedVnodeQueue.length; ++i) {
    insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);
  }

  for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();

  return vnode;
};

}

},{“./htmldomapi”:3,“./is”:5,“./vnode”:13}],5:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.primitive = primitive; exports.array = void 0; const array = Array.isArray; exports.array = array;

function primitive(s) {

return typeof s === "string" || typeof s === "number" || s instanceof String || s instanceof Number;

}

},{}],6:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.attributesModule = void 0; const xlinkNS = “www.w3.org/1999/xlink”; const xmlNS = “www.w3.org/XML/1998/namespace”; const colonChar = 58; const xChar = 120;

function updateAttrs(oldVnode, vnode) {

let key;
const elm = vnode.elm;
let oldAttrs = oldVnode.data.attrs;
let attrs = vnode.data.attrs;
if (!oldAttrs && !attrs) return;
if (oldAttrs === attrs) return;
oldAttrs = oldAttrs || {};
attrs = attrs || {}; // update modified attributes, add new attributes

for (key in attrs) {
  const cur = attrs[key];
  const old = oldAttrs[key];

  if (old !== cur) {
    if (cur === true) {
      elm.setAttribute(key, "");
    } else if (cur === false) {
      elm.removeAttribute(key);
    } else {
      if (key.charCodeAt(0) !== xChar) {
        elm.setAttribute(key, cur);
      } else if (key.charCodeAt(3) === colonChar) {
        // Assume xml namespace
        elm.setAttributeNS(xmlNS, key, cur);
      } else if (key.charCodeAt(5) === colonChar) {
        // Assume xlink namespace
        elm.setAttributeNS(xlinkNS, key, cur);
      } else {
        elm.setAttribute(key, cur);
      }
    }
  }
} // remove removed attributes
// use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)
// the other option is to remove all attributes with value == undefined

for (key in oldAttrs) {
  if (!(key in attrs)) {
    elm.removeAttribute(key);
  }
}

}

const attributesModule = {

create: updateAttrs,
update: updateAttrs

}; exports.attributesModule = attributesModule;

},{}],7:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.classModule = void 0;

function updateClass(oldVnode, vnode) {

let cur;
let name;
const elm = vnode.elm;
let oldClass = oldVnode.data.class;
let klass = vnode.data.class;
if (!oldClass && !klass) return;
if (oldClass === klass) return;
oldClass = oldClass || {};
klass = klass || {};

for (name in oldClass) {
  if (oldClass[name] && !Object.prototype.hasOwnProperty.call(klass, name)) {
    // was `true` and now not provided
    elm.classList.remove(name);
  }
}

for (name in klass) {
  cur = klass[name];

  if (cur !== oldClass[name]) {
    elm.classList[cur ? "add" : "remove"](name);
  }
}

}

const classModule = {

create: updateClass,
update: updateClass

}; exports.classModule = classModule;

},{}],8:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.datasetModule = void 0; const CAPS_REGEX = /[A-Z]/g;

function updateDataset(oldVnode, vnode) {

const elm = vnode.elm;
let oldDataset = oldVnode.data.dataset;
let dataset = vnode.data.dataset;
let key;
if (!oldDataset && !dataset) return;
if (oldDataset === dataset) return;
oldDataset = oldDataset || {};
dataset = dataset || {};
const d = elm.dataset;

for (key in oldDataset) {
  if (!dataset[key]) {
    if (d) {
      if (key in d) {
        delete d[key];
      }
    } else {
      elm.removeAttribute("data-" + key.replace(CAPS_REGEX, "-$&").toLowerCase());
    }
  }
}

for (key in dataset) {
  if (oldDataset[key] !== dataset[key]) {
    if (d) {
      d[key] = dataset[key];
    } else {
      elm.setAttribute("data-" + key.replace(CAPS_REGEX, "-$&").toLowerCase(), dataset[key]);
    }
  }
}

}

const datasetModule = {

create: updateDataset,
update: updateDataset

}; exports.datasetModule = datasetModule;

},{}],9:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.eventListenersModule = void 0;

function invokeHandler(handler, vnode, event) {

if (typeof handler === "function") {
  // call function handler
  handler.call(vnode, event, vnode);
} else if (typeof handler === "object") {
  // call multiple handlers
  for (let i = 0; i < handler.length; i++) {
    invokeHandler(handler[i], vnode, event);
  }
}

}

function handleEvent(event, vnode) {

const name = event.type;
const on = vnode.data.on; // call event handler(s) if exists

if (on && on[name]) {
  invokeHandler(on[name], vnode, event);
}

}

function createListener() {

return function handler(event) {
  handleEvent(event, handler.vnode);
};

}

function updateEventListeners(oldVnode, vnode) {

const oldOn = oldVnode.data.on;
const oldListener = oldVnode.listener;
const oldElm = oldVnode.elm;
const on = vnode && vnode.data.on;
const elm = vnode && vnode.elm;
let name; // optimization for reused immutable handlers

if (oldOn === on) {
  return;
} // remove existing listeners which no longer used

if (oldOn && oldListener) {
  // if element changed or deleted we remove all existing listeners unconditionally
  if (!on) {
    for (name in oldOn) {
      // remove listener if element was changed or existing listeners removed
      oldElm.removeEventListener(name, oldListener, false);
    }
  } else {
    for (name in oldOn) {
      // remove listener if existing listener removed
      if (!on[name]) {
        oldElm.removeEventListener(name, oldListener, false);
      }
    }
  }
} // add new listeners which has not already attached

if (on) {
  // reuse existing listener or create new
  const listener = vnode.listener = oldVnode.listener || createListener(); // update vnode for listener

  listener.vnode = vnode; // if element changed or added we add all needed listeners unconditionally

  if (!oldOn) {
    for (name in on) {
      // add listener if element was changed or new listeners added
      elm.addEventListener(name, listener, false);
    }
  } else {
    for (name in on) {
      // add listener if new listener added
      if (!oldOn[name]) {
        elm.addEventListener(name, listener, false);
      }
    }
  }
}

}

const eventListenersModule = {

create: updateEventListeners,
update: updateEventListeners,
destroy: updateEventListeners

}; exports.eventListenersModule = eventListenersModule;

},{}],10:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.propsModule = void 0;

function updateProps(oldVnode, vnode) {

let key;
let cur;
let old;
const elm = vnode.elm;
let oldProps = oldVnode.data.props;
let props = vnode.data.props;
if (!oldProps && !props) return;
if (oldProps === props) return;
oldProps = oldProps || {};
props = props || {};

for (key in props) {
  cur = props[key];
  old = oldProps[key];

  if (old !== cur && (key !== "value" || elm[key] !== cur)) {
    elm[key] = cur;
  }
}

}

const propsModule = {

create: updateProps,
update: updateProps

}; exports.propsModule = propsModule;

},{}],11:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.styleModule = void 0; // Bindig `requestAnimationFrame` like this fixes a bug in IE/Edge. See #360 and #409. const raf = typeof window !== “undefined” && window.requestAnimationFrame.bind(window) || setTimeout;

const nextFrame = function (fn) {

raf(function () {
  raf(fn);
});

};

let reflowForced = false;

function setNextFrame(obj, prop, val) {

nextFrame(function () {
  obj[prop] = val;
});

}

function updateStyle(oldVnode, vnode) {

let cur;
let name;
const elm = vnode.elm;
let oldStyle = oldVnode.data.style;
let style = vnode.data.style;
if (!oldStyle && !style) return;
if (oldStyle === style) return;
oldStyle = oldStyle || {};
style = style || {};
const oldHasDel = ("delayed" in oldStyle);

for (name in oldStyle) {
  if (!style[name]) {
    if (name[0] === "-" && name[1] === "-") {
      elm.style.removeProperty(name);
    } else {
      elm.style[name] = "";
    }
  }
}

for (name in style) {
  cur = style[name];

  if (name === "delayed" && style.delayed) {
    for (const name2 in style.delayed) {
      cur = style.delayed[name2];

      if (!oldHasDel || cur !== oldStyle.delayed[name2]) {
        setNextFrame(elm.style, name2, cur);
      }
    }
  } else if (name !== "remove" && cur !== oldStyle[name]) {
    if (name[0] === "-" && name[1] === "-") {
      elm.style.setProperty(name, cur);
    } else {
      elm.style[name] = cur;
    }
  }
}

}

function applyDestroyStyle(vnode) {

let style;
let name;
const elm = vnode.elm;
const s = vnode.data.style;
if (!s || !(style = s.destroy)) return;

for (name in style) {
  elm.style[name] = style[name];
}

}

function applyRemoveStyle(vnode, rm) {

const s = vnode.data.style;

if (!s || !s.remove) {
  rm();
  return;
}

if (!reflowForced) {
  // eslint-disable-next-line @typescript-eslint/no-unused-expressions
  vnode.elm.offsetLeft;
  reflowForced = true;
}

let name;
const elm = vnode.elm;
let i = 0;
const style = s.remove;
let amount = 0;
const applied = [];

for (name in style) {
  applied.push(name);
  elm.style[name] = style[name];
}

const compStyle = getComputedStyle(elm);
const props = compStyle["transition-property"].split(", ");

for (; i < props.length; ++i) {
  if (applied.indexOf(props[i]) !== -1) amount++;
}

elm.addEventListener("transitionend", function (ev) {
  if (ev.target === elm) --amount;
  if (amount === 0) rm();
});

}

function forceReflow() {

reflowForced = false;

}

const styleModule = {

pre: forceReflow,
create: updateStyle,
update: updateStyle,
destroy: applyDestroyStyle,
remove: applyRemoveStyle

}; exports.styleModule = styleModule;

},{}],12:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.toVNode = toVNode;

var _vnode = require(“./vnode”);

var _htmldomapi = require(“./htmldomapi”);

function toVNode(node, domApi) {

const api = domApi !== undefined ? domApi : _htmldomapi.htmlDomApi;
let text;

if (api.isElement(node)) {
  const id = node.id ? "#" + node.id : "";
  const cn = node.getAttribute("class");
  const c = cn ? "." + cn.split(" ").join(".") : "";
  const sel = api.tagName(node).toLowerCase() + id + c;
  const attrs = {};
  const children = [];
  let name;
  let i, n;
  const elmAttrs = node.attributes;
  const elmChildren = node.childNodes;

  for (i = 0, n = elmAttrs.length; i < n; i++) {
    name = elmAttrs[i].nodeName;

    if (name !== "id" && name !== "class") {
      attrs[name] = elmAttrs[i].nodeValue;
    }
  }

  for (i = 0, n = elmChildren.length; i < n; i++) {
    children.push(toVNode(elmChildren[i], domApi));
  }

  return (0, _vnode.vnode)(sel, {
    attrs
  }, children, undefined, node);
} else if (api.isText(node)) {
  text = api.getTextContent(node);
  return (0, _vnode.vnode)(undefined, undefined, undefined, text, node);
} else if (api.isComment(node)) {
  text = api.getTextContent(node);
  return (0, _vnode.vnode)("!", {}, [], text, node);
} else {
  return (0, _vnode.vnode)("", {}, [], undefined, node);
}

}

},{“./htmldomapi”:3,“./vnode”:13}],13:[function(require,module,exports){ “use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.vnode = vnode;

function vnode(sel, data, children, text, elm) {

const key = data === undefined ? undefined : data.key;
return {
  sel,
  data,
  children,
  text,
  elm,
  key
};

}

},{}]},{},[1])(1) });