(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”; Object.defineProperty(exports, “__esModule”, { value: true }); var vnode_1 = require(“./vnode”); var is = require(“./is”); function addNS(data, children, sel) {

data.ns = 'http://www.w3.org/2000/svg';
if (sel !== 'foreignObject' && children !== undefined) {
    for (var i = 0; i < children.length; ++i) {
        var childData = children[i].data;
        if (childData !== undefined) {
            addNS(childData, children[i].children, children[i].sel);
        }
    }
}

} function h(sel, b, c) {

var data = {}, children, text, i;
if (c !== undefined) {
    data = b;
    if (is.array(c)) {
        children = c;
    }
    else if (is.primitive(c)) {
        text = c;
    }
    else if (c && c.sel) {
        children = [c];
    }
}
else if (b !== undefined) {
    if (is.array(b)) {
        children = b;
    }
    else if (is.primitive(b)) {
        text = b;
    }
    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] = vnode_1.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 vnode_1.vnode(sel, data, children, text, undefined);

} exports.h = h; ; exports.default = h;

},{“./is”:3,“./vnode”:12}],2:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); function createElement(tagName) {

return document.createElement(tagName);

} function createElementNS(namespaceURI, qualifiedName) {

return document.createElementNS(namespaceURI, qualifiedName);

} 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;

} exports.htmlDomApi = {

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

}; exports.default = exports.htmlDomApi;

},{}],3:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); exports.array = Array.isArray; function primitive(s) {

return typeof s === 'string' || typeof s === 'number';

} exports.primitive = primitive;

},{}],4:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); var xlinkNS = 'www.w3.org/1999/xlink'; var xmlNS = 'www.w3.org/XML/1998/namespace'; var colonChar = 58; var xChar = 120; function updateAttrs(oldVnode, vnode) {

var key, elm = vnode.elm, oldAttrs = oldVnode.data.attrs, 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) {
    var cur = attrs[key];
    var 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);
    }
}

} exports.attributesModule = { create: updateAttrs, update: updateAttrs }; exports.default = exports.attributesModule;

},{}],5:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); function updateClass(oldVnode, vnode) {

var cur, name, elm = vnode.elm, oldClass = oldVnode.data.class, klass = vnode.data.class;
if (!oldClass && !klass)
    return;
if (oldClass === klass)
    return;
oldClass = oldClass || {};
klass = klass || {};
for (name in oldClass) {
    if (!klass[name]) {
        elm.classList.remove(name);
    }
}
for (name in klass) {
    cur = klass[name];
    if (cur !== oldClass[name]) {
        elm.classList[cur ? 'add' : 'remove'](name);
    }
}

} exports.classModule = { create: updateClass, update: updateClass }; exports.default = exports.classModule;

},{}],6:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); var CAPS_REGEX = /[A-Z]/g; function updateDataset(oldVnode, vnode) {

var elm = vnode.elm, oldDataset = oldVnode.data.dataset, dataset = vnode.data.dataset, key;
if (!oldDataset && !dataset)
    return;
if (oldDataset === dataset)
    return;
oldDataset = oldDataset || {};
dataset = dataset || {};
var 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]);
        }
    }
}

} exports.datasetModule = { create: updateDataset, update: updateDataset }; exports.default = exports.datasetModule;

},{}],7:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); function invokeHandler(handler, vnode, event) {

if (typeof handler === "function") {
    // call function handler
    handler.call(vnode, event, vnode);
}
else if (typeof handler === "object") {
    // call handler with arguments
    if (typeof handler[0] === "function") {
        // special case for single argument for performance
        if (handler.length === 2) {
            handler[0].call(vnode, handler[1], event, vnode);
        }
        else {
            var args = handler.slice(1);
            args.push(event);
            args.push(vnode);
            handler[0].apply(vnode, args);
        }
    }
    else {
        // call multiple handlers
        for (var i = 0; i < handler.length; i++) {
            invokeHandler(handler[i], vnode, event);
        }
    }
}

} function handleEvent(event, vnode) {

var name = event.type, 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) {

var oldOn = oldVnode.data.on, oldListener = oldVnode.listener, oldElm = oldVnode.elm, on = vnode && vnode.data.on, elm = (vnode && vnode.elm), 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
    var 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);
            }
        }
    }
}

} exports.eventListenersModule = {

create: updateEventListeners,
update: updateEventListeners,
destroy: updateEventListeners

}; exports.default = exports.eventListenersModule;

},{}],8:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); function updateProps(oldVnode, vnode) {

var key, cur, old, elm = vnode.elm, oldProps = oldVnode.data.props, props = vnode.data.props;
if (!oldProps && !props)
    return;
if (oldProps === props)
    return;
oldProps = oldProps || {};
props = props || {};
for (key in oldProps) {
    if (!props[key]) {
        delete elm[key];
    }
}
for (key in props) {
    cur = props[key];
    old = oldProps[key];
    if (old !== cur && (key !== 'value' || elm[key] !== cur)) {
        elm[key] = cur;
    }
}

} exports.propsModule = { create: updateProps, update: updateProps }; exports.default = exports.propsModule;

},{}],9:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); // Bindig `requestAnimationFrame` like this fixes a bug in IE/Edge. See #360 and #409. var raf = (typeof window !== 'undefined' && (window.requestAnimationFrame).bind(window)) || setTimeout; var nextFrame = function (fn) { raf(function () { raf(fn); }); }; var reflowForced = false; function setNextFrame(obj, prop, val) {

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

} function updateStyle(oldVnode, vnode) {

var cur, name, elm = vnode.elm, oldStyle = oldVnode.data.style, style = vnode.data.style;
if (!oldStyle && !style)
    return;
if (oldStyle === style)
    return;
oldStyle = oldStyle || {};
style = style || {};
var 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 (var 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) {

var style, name, elm = vnode.elm, s = vnode.data.style;
if (!s || !(style = s.destroy))
    return;
for (name in style) {
    elm.style[name] = style[name];
}

} function applyRemoveStyle(vnode, rm) {

var s = vnode.data.style;
if (!s || !s.remove) {
    rm();
    return;
}
if (!reflowForced) {
    getComputedStyle(document.body).transform;
    reflowForced = true;
}
var name, elm = vnode.elm, i = 0, compStyle, style = s.remove, amount = 0, applied = [];
for (name in style) {
    applied.push(name);
    elm.style[name] = style[name];
}
compStyle = getComputedStyle(elm);
var 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;

} exports.styleModule = {

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

}; exports.default = exports.styleModule;

},{}],10:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); var vnode_1 = require(“./vnode”); var is = require(“./is”); var htmldomapi_1 = require(“./htmldomapi”); function isUndef(s) { return s === undefined; } function isDef(s) { return s !== undefined; } var emptyNode = vnode_1.default('', {}, [], undefined, undefined); function sameVnode(vnode1, vnode2) {

return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;

} function isVnode(vnode) {

return vnode.sel !== undefined;

} function createKeyToOldIdx(children, beginIdx, endIdx) {

var i, map = {}, key, ch;
for (i = beginIdx; i <= endIdx; ++i) {
    ch = children[i];
    if (ch != null) {
        key = ch.key;
        if (key !== undefined)
            map[key] = i;
    }
}
return map;

} var hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post']; var h_1 = require(“./h”); exports.h = h_1.h; var thunk_1 = require(“./thunk”); exports.thunk = thunk_1.thunk; function init(modules, domApi) {

var i, j, cbs = {};
var api = domApi !== undefined ? domApi : htmldomapi_1.default;
for (i = 0; i < hooks.length; ++i) {
    cbs[hooks[i]] = [];
    for (j = 0; j < modules.length; ++j) {
        var hook = modules[j][hooks[i]];
        if (hook !== undefined) {
            cbs[hooks[i]].push(hook);
        }
    }
}
function emptyNodeAt(elm) {
    var id = elm.id ? '#' + elm.id : '';
    var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';
    return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);
}
function createRmCb(childElm, listeners) {
    return function rmCb() {
        if (--listeners === 0) {
            var parent_1 = api.parentNode(childElm);
            api.removeChild(parent_1, childElm);
        }
    };
}
function createElm(vnode, insertedVnodeQueue) {
    var i, data = vnode.data;
    if (data !== undefined) {
        if (isDef(i = data.hook) && isDef(i = i.init)) {
            i(vnode);
            data = vnode.data;
        }
    }
    var children = vnode.children, sel = vnode.sel;
    if (sel === '!') {
        if (isUndef(vnode.text)) {
            vnode.text = '';
        }
        vnode.elm = api.createComment(vnode.text);
    }
    else if (sel !== undefined) {
        // Parse selector
        var hashIdx = sel.indexOf('#');
        var dotIdx = sel.indexOf('.', hashIdx);
        var hash = hashIdx > 0 ? hashIdx : sel.length;
        var dot = dotIdx > 0 ? dotIdx : sel.length;
        var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;
        var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)
            : api.createElement(tag);
        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) {
                var 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));
        }
        i = vnode.data.hook; // Reuse variable
        if (isDef(i)) {
            if (i.create)
                i.create(emptyNode, vnode);
            if (i.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) {
        var ch = vnodes[startIdx];
        if (ch != null) {
            api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);
        }
    }
}
function invokeDestroyHook(vnode) {
    var i, j, data = vnode.data;
    if (data !== undefined) {
        if (isDef(i = data.hook) && isDef(i = i.destroy))
            i(vnode);
        for (i = 0; i < cbs.destroy.length; ++i)
            cbs.destroy[i](vnode);
        if (vnode.children !== undefined) {
            for (j = 0; j < vnode.children.length; ++j) {
                i = vnode.children[j];
                if (i != null && typeof i !== "string") {
                    invokeDestroyHook(i);
                }
            }
        }
    }
}
function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
    for (; startIdx <= endIdx; ++startIdx) {
        var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];
        if (ch != null) {
            if (isDef(ch.sel)) {
                invokeDestroyHook(ch);
                listeners = cbs.remove.length + 1;
                rm = createRmCb(ch.elm, listeners);
                for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)
                    cbs.remove[i_1](ch, rm);
                if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {
                    i_1(ch, rm);
                }
                else {
                    rm();
                }
            }
            else {
                api.removeChild(parentElm, ch.elm);
            }
        }
    }
}
function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {
    var oldStartIdx = 0, newStartIdx = 0;
    var oldEndIdx = oldCh.length - 1;
    var oldStartVnode = oldCh[0];
    var oldEndVnode = oldCh[oldEndIdx];
    var newEndIdx = newCh.length - 1;
    var newStartVnode = newCh[0];
    var newEndVnode = newCh[newEndIdx];
    var oldKeyToIdx;
    var idxInOld;
    var elmToMove;
    var 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)) {
            patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
            api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));
            oldStartVnode = oldCh[++oldStartIdx];
            newEndVnode = newCh[--newEndIdx];
        }
        else if (sameVnode(oldEndVnode, newStartVnode)) {
            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)) {
                api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
                newStartVnode = newCh[++newStartIdx];
            }
            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 i, hook;
    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {
        i(oldVnode, vnode);
    }
    var elm = vnode.elm = oldVnode.elm;
    var oldCh = oldVnode.children;
    var ch = vnode.children;
    if (oldVnode === vnode)
        return;
    if (vnode.data !== undefined) {
        for (i = 0; i < cbs.update.length; ++i)
            cbs.update[i](oldVnode, vnode);
        i = vnode.data.hook;
        if (isDef(i) && isDef(i = i.update))
            i(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);
    }
    if (isDef(hook) && isDef(i = hook.postpatch)) {
        i(oldVnode, vnode);
    }
}
return function patch(oldVnode, vnode) {
    var i, elm, parent;
    var 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;
};

} exports.init = init;

},{“./h”:1,“./htmldomapi”:2,“./is”:3,“./thunk”:11,“./vnode”:12}],11:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); var h_1 = require(“./h”); function copyToThunk(vnode, thunk) {

thunk.elm = vnode.elm;
vnode.data.fn = thunk.data.fn;
vnode.data.args = thunk.data.args;
thunk.data = vnode.data;
thunk.children = vnode.children;
thunk.text = vnode.text;
thunk.elm = vnode.elm;

} function init(thunk) {

var cur = thunk.data;
var vnode = cur.fn.apply(undefined, cur.args);
copyToThunk(vnode, thunk);

} function prepatch(oldVnode, thunk) {

var i, old = oldVnode.data, cur = thunk.data;
var oldArgs = old.args, args = cur.args;
if (old.fn !== cur.fn || oldArgs.length !== args.length) {
    copyToThunk(cur.fn.apply(undefined, args), thunk);
    return;
}
for (i = 0; i < args.length; ++i) {
    if (oldArgs[i] !== args[i]) {
        copyToThunk(cur.fn.apply(undefined, args), thunk);
        return;
    }
}
copyToThunk(oldVnode, thunk);

} exports.thunk = function thunk(sel, key, fn, args) {

if (args === undefined) {
    args = fn;
    fn = key;
    key = undefined;
}
return h_1.h(sel, {
    key: key,
    hook: { init: init, prepatch: prepatch },
    fn: fn,
    args: args
});

}; exports.default = exports.thunk;

},{“./h”:1}],12:[function(require,module,exports){ “use strict”; Object.defineProperty(exports, “__esModule”, { value: true }); function vnode(sel, data, children, text, elm) {

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

} exports.vnode = vnode; exports.default = vnode;

},{}],13:[function(require,module,exports){ var snabbdom = require('snabbdom'); var patch = snabbdom.init([

require('snabbdom/modules/class').default,
require('snabbdom/modules/attributes').default,
require('snabbdom/modules/props').default,
require('snabbdom/modules/style').default,
require('snabbdom/modules/eventlisteners').default,
require('snabbdom/modules/dataset').default

]); snabbdom_h = require('snabbdom/h').default;

function stringifyEvent(e) {

const obj = {};
for (let k in e) {
  obj[k] = e[k];
}
return JSON.stringify(obj, (k, v) => {
  if (v instanceof Node) return 'Node';
  if (v instanceof Window) return 'Window';
  return v;
}, ' ');

}

window.stringifyEvent = stringifyEvent;

function rubyVTreeToSnabbdom(rvtree) {

if (rvtree.type === "text") { return rvtree.content; }

let options = {};

for (let key in rvtree) {
  if (key === "_children") { continue; }
  if (key === "_type") { continue; }
  if (key === "_class") { continue; }
  if (key === "onClick") { continue; }
  if (key === "onKeydown") { continue; }
  if (key === "onInput") { continue; }

  options[key] = rvtree[key];
}

if (options.on) {
  for (let key in options.on) {
    var handler = options.on[key];

    options.on[key] = function(event) {
      if (handler.prevent_default) {
        event.preventDefault();
      }

      if (handler.stop_propagation) {
        event.stopPropagation();
      }

      let args = [];

      for (let arg of handler.args) {
        if (arg.type === "event") {
          args.push(serializeEvent(event));
        }

        if (arg.type === "event_data") {
          args.push(event[arg.key]);
        }

        if (arg.type === "target_data") {
          args.push(event.target[arg.key]);
        }
      }

      var handlerWithArgs = Object.assign(
        {},
        handler,
        {args}
      );

      if (handlerWithArgs.type) {
        Module.ccall("dispatch", "void", ["string"], [JSON.stringify(handlerWithArgs)]);
      }
      render();
    }
  }
}

return snabbdom_h(
  rvtree._type + (rvtree._class || ""),
  options,
  (rvtree._children || []).map(rubyVTreeToSnabbdom)
);

}

var currentContainer; var allLoaded = false; var modulesToLoad = [];

function run(element, main, config = {}) {

currentContainer = element;
modulesToLoad = [fetchAndLoad("/prism-ruby/prism.rb"), fetchAndLoad(main)];

load(modulesToLoad, main, config);

}

window.Prism = {run};

function render() {

const rvtree = JSON.parse(Module.ccall("render", "string", []));
const vtree = rubyVTreeToSnabbdom(rvtree);

patch(currentContainer, vtree);

currentContainer = vtree;

}

window.render = render;

function fetchAndLoad(name) {

return fetch(name).then(r => r.text().then(t => ({ok: r.ok, text: t}))).then(({ok, text}) => {
  if (!ok) {
    throw new Error(`Prism: Could not load ${name}`, text);
  }

  return {name, text};
});

}

function load(modulesToLoad, main, config = {}) {

modulePromise.then(() => {
  Promise.all(modulesToLoad).then((modules) => {
    for (let m of modules) {
      const parts = m.name.split('/').filter(a => a.trim() !== '');

      const directories = parts.slice(0, -1);
      const basename = parts.slice(-1)[0];

      const pwd = [];
      for (let d of directories) {
        FS.mkdir('./' + pwd.concat(d).join('/'));
        pwd.push(d);
      }

      FS.writeFile(`./${m.name}`, m.text);
    }

    const result = Module.ccall("load", "number", ["string", "string"], [main, JSON.stringify(config)]);
    if (result === 0) {
      render();
    }
  });
});

}

const modulePromise = new Promise((resolve, reject) => {

window.Module = {
  preRun: [],
  postRun: [ resolve ],
  print: function() {
    return function(e) {
      1 < arguments.length && (e = Array.prototype.slice.call(arguments).join(" ")), console.log(e)
    }
  }(),
  printErr: function(e) {
    1 < arguments.length && (e = Array.prototype.slice.call(arguments).join(" ")), console.error(e)
  },
  canvas: function() {}(),
  setStatus: function() {},
  totalDependencies: 0,
  monitorRunDependencies: function(e) {}
};

});

},{“snabbdom”:10,“snabbdom/h”:1,“snabbdom/modules/attributes”:4,“snabbdom/modules/class”:5,“snabbdom/modules/dataset”:6,“snabbdom/modules/eventlisteners”:7,“snabbdom/modules/props”:8,“snabbdom/modules/style”:9}]},{},[13]);