made with requirebin
Last active
October 7, 2016 04:00
-
-
Save ahdinosaur/f0c29e3eabc23a1c40c0c3e325f241a0 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| var html = require('yo-yo') | |
| var node = render() | |
| document.body.appendChild(node) | |
| function render (content) { | |
| return html` | |
| <div> | |
| <textarea | |
| placeholder="type here!" | |
| ></textarea> | |
| <button | |
| onclick=${update} | |
| >click me!</button> | |
| </div> | |
| ` | |
| } | |
| function update () { | |
| html.update(node, render()) | |
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| setTimeout(function(){ | |
| ;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| },{}],2:[function(require,module,exports){ | |
| var document = require('global/document') | |
| var hyperx = require('hyperx') | |
| var onload = require('on-load') | |
| var SVGNS = 'http://www.w3.org/2000/svg' | |
| var BOOL_PROPS = { | |
| autofocus: 1, | |
| checked: 1, | |
| defaultchecked: 1, | |
| disabled: 1, | |
| formnovalidate: 1, | |
| indeterminate: 1, | |
| readonly: 1, | |
| required: 1, | |
| selected: 1, | |
| willvalidate: 1 | |
| } | |
| var SVG_TAGS = [ | |
| 'svg', | |
| 'altGlyph', 'altGlyphDef', 'altGlyphItem', 'animate', 'animateColor', | |
| 'animateMotion', 'animateTransform', 'circle', 'clipPath', 'color-profile', | |
| 'cursor', 'defs', 'desc', 'ellipse', 'feBlend', 'feColorMatrix', | |
| 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', | |
| 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', | |
| 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', | |
| 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', | |
| 'feSpotLight', 'feTile', 'feTurbulence', 'filter', 'font', 'font-face', | |
| 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', | |
| 'foreignObject', 'g', 'glyph', 'glyphRef', 'hkern', 'image', 'line', | |
| 'linearGradient', 'marker', 'mask', 'metadata', 'missing-glyph', 'mpath', | |
| 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', | |
| 'set', 'stop', 'switch', 'symbol', 'text', 'textPath', 'title', 'tref', | |
| 'tspan', 'use', 'view', 'vkern' | |
| ] | |
| function belCreateElement (tag, props, children) { | |
| var el | |
| // If an svg tag, it needs a namespace | |
| if (SVG_TAGS.indexOf(tag) !== -1) { | |
| props.namespace = SVGNS | |
| } | |
| // If we are using a namespace | |
| var ns = false | |
| if (props.namespace) { | |
| ns = props.namespace | |
| delete props.namespace | |
| } | |
| // Create the element | |
| if (ns) { | |
| el = document.createElementNS(ns, tag) | |
| } else { | |
| el = document.createElement(tag) | |
| } | |
| // If adding onload events | |
| if (props.onload || props.onunload) { | |
| var load = props.onload || function () {} | |
| var unload = props.onunload || function () {} | |
| onload(el, function bel_onload () { | |
| load(el) | |
| }, function bel_onunload () { | |
| unload(el) | |
| }, | |
| // We have to use non-standard `caller` to find who invokes `belCreateElement` | |
| belCreateElement.caller.caller.caller) | |
| delete props.onload | |
| delete props.onunload | |
| } | |
| // Create the properties | |
| for (var p in props) { | |
| if (props.hasOwnProperty(p)) { | |
| var key = p.toLowerCase() | |
| var val = props[p] | |
| // Normalize className | |
| if (key === 'classname') { | |
| key = 'class' | |
| p = 'class' | |
| } | |
| // The for attribute gets transformed to htmlFor, but we just set as for | |
| if (p === 'htmlFor') { | |
| p = 'for' | |
| } | |
| // If a property is boolean, set itself to the key | |
| if (BOOL_PROPS[key]) { | |
| if (val === 'true') val = key | |
| else if (val === 'false') continue | |
| } | |
| // If a property prefers being set directly vs setAttribute | |
| if (key.slice(0, 2) === 'on') { | |
| el[p] = val | |
| } else { | |
| if (ns) { | |
| el.setAttributeNS(null, p, val) | |
| } else { | |
| el.setAttribute(p, val) | |
| } | |
| } | |
| } | |
| } | |
| function appendChild (childs) { | |
| if (!Array.isArray(childs)) return | |
| for (var i = 0; i < childs.length; i++) { | |
| var node = childs[i] | |
| if (Array.isArray(node)) { | |
| appendChild(node) | |
| continue | |
| } | |
| if (typeof node === 'number' || | |
| typeof node === 'boolean' || | |
| node instanceof Date || | |
| node instanceof RegExp) { | |
| node = node.toString() | |
| } | |
| if (typeof node === 'string') { | |
| if (el.lastChild && el.lastChild.nodeName === '#text') { | |
| el.lastChild.nodeValue += node | |
| continue | |
| } | |
| node = document.createTextNode(node) | |
| } | |
| if (node && node.nodeType) { | |
| el.appendChild(node) | |
| } | |
| } | |
| } | |
| appendChild(children) | |
| return el | |
| } | |
| module.exports = hyperx(belCreateElement) | |
| module.exports.createElement = belCreateElement | |
| },{"global/document":3,"hyperx":5,"on-load":7}],3:[function(require,module,exports){ | |
| (function (global){ | |
| var topLevel = typeof global !== 'undefined' ? global : | |
| typeof window !== 'undefined' ? window : {} | |
| var minDoc = require('min-document'); | |
| if (typeof document !== 'undefined') { | |
| module.exports = document; | |
| } else { | |
| var doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4']; | |
| if (!doccy) { | |
| doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc; | |
| } | |
| module.exports = doccy; | |
| } | |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
| //# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9iZWwvbm9kZV9tb2R1bGVzL2dsb2JhbC9kb2N1bWVudC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EiLCJmaWxlIjoiZ2VuZXJhdGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXNDb250ZW50IjpbInZhciB0b3BMZXZlbCA9IHR5cGVvZiBnbG9iYWwgIT09ICd1bmRlZmluZWQnID8gZ2xvYmFsIDpcbiAgICB0eXBlb2Ygd2luZG93ICE9PSAndW5kZWZpbmVkJyA/IHdpbmRvdyA6IHt9XG52YXIgbWluRG9jID0gcmVxdWlyZSgnbWluLWRvY3VtZW50Jyk7XG5cbmlmICh0eXBlb2YgZG9jdW1lbnQgIT09ICd1bmRlZmluZWQnKSB7XG4gICAgbW9kdWxlLmV4cG9ydHMgPSBkb2N1bWVudDtcbn0gZWxzZSB7XG4gICAgdmFyIGRvY2N5ID0gdG9wTGV2ZWxbJ19fR0xPQkFMX0RPQ1VNRU5UX0NBQ0hFQDQnXTtcblxuICAgIGlmICghZG9jY3kpIHtcbiAgICAgICAgZG9jY3kgPSB0b3BMZXZlbFsnX19HTE9CQUxfRE9DVU1FTlRfQ0FDSEVANCddID0gbWluRG9jO1xuICAgIH1cblxuICAgIG1vZHVsZS5leHBvcnRzID0gZG9jY3k7XG59XG4iXX0= | |
| },{"min-document":1}],4:[function(require,module,exports){ | |
| (function (global){ | |
| if (typeof window !== "undefined") { | |
| module.exports = window; | |
| } else if (typeof global !== "undefined") { | |
| module.exports = global; | |
| } else if (typeof self !== "undefined"){ | |
| module.exports = self; | |
| } else { | |
| module.exports = {}; | |
| } | |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
| //# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9iZWwvbm9kZV9tb2R1bGVzL2dsb2JhbC93aW5kb3cuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpZiAodHlwZW9mIHdpbmRvdyAhPT0gXCJ1bmRlZmluZWRcIikge1xuICAgIG1vZHVsZS5leHBvcnRzID0gd2luZG93O1xufSBlbHNlIGlmICh0eXBlb2YgZ2xvYmFsICE9PSBcInVuZGVmaW5lZFwiKSB7XG4gICAgbW9kdWxlLmV4cG9ydHMgPSBnbG9iYWw7XG59IGVsc2UgaWYgKHR5cGVvZiBzZWxmICE9PSBcInVuZGVmaW5lZFwiKXtcbiAgICBtb2R1bGUuZXhwb3J0cyA9IHNlbGY7XG59IGVsc2Uge1xuICAgIG1vZHVsZS5leHBvcnRzID0ge307XG59XG4iXX0= | |
| },{}],5:[function(require,module,exports){ | |
| var attrToProp = require('hyperscript-attribute-to-property') | |
| var VAR = 0, TEXT = 1, OPEN = 2, CLOSE = 3, ATTR = 4 | |
| var ATTR_KEY = 5, ATTR_KEY_W = 6 | |
| var ATTR_VALUE_W = 7, ATTR_VALUE = 8 | |
| var ATTR_VALUE_SQ = 9, ATTR_VALUE_DQ = 10 | |
| var ATTR_EQ = 11, ATTR_BREAK = 12 | |
| module.exports = function (h, opts) { | |
| h = attrToProp(h) | |
| if (!opts) opts = {} | |
| var concat = opts.concat || function (a, b) { | |
| return String(a) + String(b) | |
| } | |
| return function (strings) { | |
| var state = TEXT, reg = '' | |
| var arglen = arguments.length | |
| var parts = [] | |
| for (var i = 0; i < strings.length; i++) { | |
| if (i < arglen - 1) { | |
| var arg = arguments[i+1] | |
| var p = parse(strings[i]) | |
| var xstate = state | |
| if (xstate === ATTR_VALUE_DQ) xstate = ATTR_VALUE | |
| if (xstate === ATTR_VALUE_SQ) xstate = ATTR_VALUE | |
| if (xstate === ATTR_VALUE_W) xstate = ATTR_VALUE | |
| if (xstate === ATTR) xstate = ATTR_KEY | |
| p.push([ VAR, xstate, arg ]) | |
| parts.push.apply(parts, p) | |
| } else parts.push.apply(parts, parse(strings[i])) | |
| } | |
| var tree = [null,{},[]] | |
| var stack = [[tree,-1]] | |
| for (var i = 0; i < parts.length; i++) { | |
| var cur = stack[stack.length-1][0] | |
| var p = parts[i], s = p[0] | |
| if (s === OPEN && /^\//.test(p[1])) { | |
| var ix = stack[stack.length-1][1] | |
| if (stack.length > 1) { | |
| stack.pop() | |
| stack[stack.length-1][0][2][ix] = h( | |
| cur[0], cur[1], cur[2].length ? cur[2] : undefined | |
| ) | |
| } | |
| } else if (s === OPEN) { | |
| var c = [p[1],{},[]] | |
| cur[2].push(c) | |
| stack.push([c,cur[2].length-1]) | |
| } else if (s === ATTR_KEY || (s === VAR && p[1] === ATTR_KEY)) { | |
| var key = '' | |
| var copyKey | |
| for (; i < parts.length; i++) { | |
| if (parts[i][0] === ATTR_KEY) { | |
| key = concat(key, parts[i][1]) | |
| } else if (parts[i][0] === VAR && parts[i][1] === ATTR_KEY) { | |
| if (typeof parts[i][2] === 'object' && !key) { | |
| for (copyKey in parts[i][2]) { | |
| if (parts[i][2].hasOwnProperty(copyKey) && !cur[1][copyKey]) { | |
| cur[1][copyKey] = parts[i][2][copyKey] | |
| } | |
| } | |
| } else { | |
| key = concat(key, parts[i][2]) | |
| } | |
| } else break | |
| } | |
| if (parts[i][0] === ATTR_EQ) i++ | |
| var j = i | |
| for (; i < parts.length; i++) { | |
| if (parts[i][0] === ATTR_VALUE || parts[i][0] === ATTR_KEY) { | |
| if (!cur[1][key]) cur[1][key] = strfn(parts[i][1]) | |
| else cur[1][key] = concat(cur[1][key], parts[i][1]) | |
| } else if (parts[i][0] === VAR | |
| && (parts[i][1] === ATTR_VALUE || parts[i][1] === ATTR_KEY)) { | |
| if (!cur[1][key]) cur[1][key] = strfn(parts[i][2]) | |
| else cur[1][key] = concat(cur[1][key], parts[i][2]) | |
| } else { | |
| if (key.length && !cur[1][key] && i === j | |
| && (parts[i][0] === CLOSE || parts[i][0] === ATTR_BREAK)) { | |
| // https://html.spec.whatwg.org/multipage/infrastructure.html#boolean-attributes | |
| // empty string is falsy, not well behaved value in browser | |
| cur[1][key] = key.toLowerCase() | |
| } | |
| break | |
| } | |
| } | |
| } else if (s === ATTR_KEY) { | |
| cur[1][p[1]] = true | |
| } else if (s === VAR && p[1] === ATTR_KEY) { | |
| cur[1][p[2]] = true | |
| } else if (s === CLOSE) { | |
| if (selfClosing(cur[0]) && stack.length) { | |
| var ix = stack[stack.length-1][1] | |
| stack.pop() | |
| stack[stack.length-1][0][2][ix] = h( | |
| cur[0], cur[1], cur[2].length ? cur[2] : undefined | |
| ) | |
| } | |
| } else if (s === VAR && p[1] === TEXT) { | |
| if (p[2] === undefined || p[2] === null) p[2] = '' | |
| else if (!p[2]) p[2] = concat('', p[2]) | |
| if (Array.isArray(p[2][0])) { | |
| cur[2].push.apply(cur[2], p[2]) | |
| } else { | |
| cur[2].push(p[2]) | |
| } | |
| } else if (s === TEXT) { | |
| cur[2].push(p[1]) | |
| } else if (s === ATTR_EQ || s === ATTR_BREAK) { | |
| // no-op | |
| } else { | |
| throw new Error('unhandled: ' + s) | |
| } | |
| } | |
| if (tree[2].length > 1 && /^\s*$/.test(tree[2][0])) { | |
| tree[2].shift() | |
| } | |
| if (tree[2].length > 2 | |
| || (tree[2].length === 2 && /\S/.test(tree[2][1]))) { | |
| throw new Error( | |
| 'multiple root elements must be wrapped in an enclosing tag' | |
| ) | |
| } | |
| if (Array.isArray(tree[2][0]) && typeof tree[2][0][0] === 'string' | |
| && Array.isArray(tree[2][0][2])) { | |
| tree[2][0] = h(tree[2][0][0], tree[2][0][1], tree[2][0][2]) | |
| } | |
| return tree[2][0] | |
| function parse (str) { | |
| var res = [] | |
| if (state === ATTR_VALUE_W) state = ATTR | |
| for (var i = 0; i < str.length; i++) { | |
| var c = str.charAt(i) | |
| if (state === TEXT && c === '<') { | |
| if (reg.length) res.push([TEXT, reg]) | |
| reg = '' | |
| state = OPEN | |
| } else if (c === '>' && !quot(state)) { | |
| if (state === OPEN) { | |
| res.push([OPEN,reg]) | |
| } else if (state === ATTR_KEY) { | |
| res.push([ATTR_KEY,reg]) | |
| } else if (state === ATTR_VALUE && reg.length) { | |
| res.push([ATTR_VALUE,reg]) | |
| } | |
| res.push([CLOSE]) | |
| reg = '' | |
| state = TEXT | |
| } else if (state === TEXT) { | |
| reg += c | |
| } else if (state === OPEN && /\s/.test(c)) { | |
| res.push([OPEN, reg]) | |
| reg = '' | |
| state = ATTR | |
| } else if (state === OPEN) { | |
| reg += c | |
| } else if (state === ATTR && /[\w-]/.test(c)) { | |
| state = ATTR_KEY | |
| reg = c | |
| } else if (state === ATTR && /\s/.test(c)) { | |
| if (reg.length) res.push([ATTR_KEY,reg]) | |
| res.push([ATTR_BREAK]) | |
| } else if (state === ATTR_KEY && /\s/.test(c)) { | |
| res.push([ATTR_KEY,reg]) | |
| reg = '' | |
| state = ATTR_KEY_W | |
| } else if (state === ATTR_KEY && c === '=') { | |
| res.push([ATTR_KEY,reg],[ATTR_EQ]) | |
| reg = '' | |
| state = ATTR_VALUE_W | |
| } else if (state === ATTR_KEY) { | |
| reg += c | |
| } else if ((state === ATTR_KEY_W || state === ATTR) && c === '=') { | |
| res.push([ATTR_EQ]) | |
| state = ATTR_VALUE_W | |
| } else if ((state === ATTR_KEY_W || state === ATTR) && !/\s/.test(c)) { | |
| res.push([ATTR_BREAK]) | |
| if (/[\w-]/.test(c)) { | |
| reg += c | |
| state = ATTR_KEY | |
| } else state = ATTR | |
| } else if (state === ATTR_VALUE_W && c === '"') { | |
| state = ATTR_VALUE_DQ | |
| } else if (state === ATTR_VALUE_W && c === "'") { | |
| state = ATTR_VALUE_SQ | |
| } else if (state === ATTR_VALUE_DQ && c === '"') { | |
| res.push([ATTR_VALUE,reg],[ATTR_BREAK]) | |
| reg = '' | |
| state = ATTR | |
| } else if (state === ATTR_VALUE_SQ && c === "'") { | |
| res.push([ATTR_VALUE,reg],[ATTR_BREAK]) | |
| reg = '' | |
| state = ATTR | |
| } else if (state === ATTR_VALUE_W && !/\s/.test(c)) { | |
| state = ATTR_VALUE | |
| i-- | |
| } else if (state === ATTR_VALUE && /\s/.test(c)) { | |
| res.push([ATTR_VALUE,reg],[ATTR_BREAK]) | |
| reg = '' | |
| state = ATTR | |
| } else if (state === ATTR_VALUE || state === ATTR_VALUE_SQ | |
| || state === ATTR_VALUE_DQ) { | |
| reg += c | |
| } | |
| } | |
| if (state === TEXT && reg.length) { | |
| res.push([TEXT,reg]) | |
| reg = '' | |
| } else if (state === ATTR_VALUE && reg.length) { | |
| res.push([ATTR_VALUE,reg]) | |
| reg = '' | |
| } else if (state === ATTR_VALUE_DQ && reg.length) { | |
| res.push([ATTR_VALUE,reg]) | |
| reg = '' | |
| } else if (state === ATTR_VALUE_SQ && reg.length) { | |
| res.push([ATTR_VALUE,reg]) | |
| reg = '' | |
| } else if (state === ATTR_KEY) { | |
| res.push([ATTR_KEY,reg]) | |
| reg = '' | |
| } | |
| return res | |
| } | |
| } | |
| function strfn (x) { | |
| if (typeof x === 'function') return x | |
| else if (typeof x === 'string') return x | |
| else if (x && typeof x === 'object') return x | |
| else return concat('', x) | |
| } | |
| } | |
| function quot (state) { | |
| return state === ATTR_VALUE_SQ || state === ATTR_VALUE_DQ | |
| } | |
| var hasOwn = Object.prototype.hasOwnProperty | |
| function has (obj, key) { return hasOwn.call(obj, key) } | |
| var closeRE = RegExp('^(' + [ | |
| 'area', 'base', 'basefont', 'bgsound', 'br', 'col', 'command', 'embed', | |
| 'frame', 'hr', 'img', 'input', 'isindex', 'keygen', 'link', 'meta', 'param', | |
| 'source', 'track', 'wbr', | |
| // SVG TAGS | |
| 'animate', 'animateTransform', 'circle', 'cursor', 'desc', 'ellipse', | |
| 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', | |
| 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', | |
| 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', | |
| 'feGaussianBlur', 'feImage', 'feMergeNode', 'feMorphology', | |
| 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', | |
| 'feTurbulence', 'font-face-format', 'font-face-name', 'font-face-uri', | |
| 'glyph', 'glyphRef', 'hkern', 'image', 'line', 'missing-glyph', 'mpath', | |
| 'path', 'polygon', 'polyline', 'rect', 'set', 'stop', 'tref', 'use', 'view', | |
| 'vkern' | |
| ].join('|') + ')(?:[\.#][a-zA-Z0-9\u007F-\uFFFF_:-]+)*$') | |
| function selfClosing (tag) { return closeRE.test(tag) } | |
| },{"hyperscript-attribute-to-property":6}],6:[function(require,module,exports){ | |
| module.exports = attributeToProperty | |
| var transform = { | |
| 'class': 'className', | |
| 'for': 'htmlFor', | |
| 'http-equiv': 'httpEquiv' | |
| } | |
| function attributeToProperty (h) { | |
| return function (tagName, attrs, children) { | |
| for (var attr in attrs) { | |
| if (attr in transform) { | |
| attrs[transform[attr]] = attrs[attr] | |
| delete attrs[attr] | |
| } | |
| } | |
| return h(tagName, attrs, children) | |
| } | |
| } | |
| },{}],7:[function(require,module,exports){ | |
| /* global MutationObserver */ | |
| var document = require('global/document') | |
| var window = require('global/window') | |
| var watch = Object.create(null) | |
| var KEY_ID = 'onloadid' + (new Date() % 9e6).toString(36) | |
| var KEY_ATTR = 'data-' + KEY_ID | |
| var INDEX = 0 | |
| if (window && window.MutationObserver) { | |
| var observer = new MutationObserver(function (mutations) { | |
| if (Object.keys(watch).length < 1) return | |
| for (var i = 0; i < mutations.length; i++) { | |
| if (mutations[i].attributeName === KEY_ATTR) { | |
| eachAttr(mutations[i], turnon, turnoff) | |
| continue | |
| } | |
| eachMutation(mutations[i].removedNodes, turnoff) | |
| eachMutation(mutations[i].addedNodes, turnon) | |
| } | |
| }) | |
| observer.observe(document.body, { | |
| childList: true, | |
| subtree: true, | |
| attributes: true, | |
| attributeOldValue: true, | |
| attributeFilter: [KEY_ATTR] | |
| }) | |
| } | |
| module.exports = function onload (el, on, off, caller) { | |
| on = on || function () {} | |
| off = off || function () {} | |
| el.setAttribute(KEY_ATTR, 'o' + INDEX) | |
| watch['o' + INDEX] = [on, off, 0, caller || onload.caller] | |
| INDEX += 1 | |
| return el | |
| } | |
| function turnon (index, el) { | |
| if (watch[index][0] && watch[index][2] === 0) { | |
| watch[index][0](el) | |
| watch[index][2] = 1 | |
| } | |
| } | |
| function turnoff (index, el) { | |
| if (watch[index][1] && watch[index][2] === 1) { | |
| watch[index][1](el) | |
| watch[index][2] = 0 | |
| } | |
| } | |
| function eachAttr (mutation, on, off) { | |
| var newValue = mutation.target.getAttribute(KEY_ATTR) | |
| if (sameOrigin(mutation.oldValue, newValue)) { | |
| watch[newValue] = watch[mutation.oldValue] | |
| return | |
| } | |
| if (watch[mutation.oldValue]) { | |
| off(mutation.oldValue, mutation.target) | |
| } | |
| if (watch[newValue]) { | |
| on(newValue, mutation.target) | |
| } | |
| } | |
| function sameOrigin (oldValue, newValue) { | |
| if (!oldValue || !newValue) return false | |
| return watch[oldValue][3] === watch[newValue][3] | |
| } | |
| function eachMutation (nodes, fn) { | |
| var keys = Object.keys(watch) | |
| for (var i = 0; i < nodes.length; i++) { | |
| if (nodes[i] && nodes[i].getAttribute && nodes[i].getAttribute(KEY_ATTR)) { | |
| var onloadid = nodes[i].getAttribute(KEY_ATTR) | |
| keys.forEach(function (k) { | |
| if (onloadid === k) { | |
| fn(k, nodes[i]) | |
| } | |
| }) | |
| } | |
| if (nodes[i].childNodes.length > 0) { | |
| eachMutation(nodes[i].childNodes, fn) | |
| } | |
| } | |
| } | |
| },{"global/document":3,"global/window":4}],8:[function(require,module,exports){ | |
| 'use strict'; | |
| // Create a range object for efficently rendering strings to elements. | |
| var range; | |
| var doc = typeof document !== 'undefined' && document; | |
| var testEl = doc ? | |
| doc.body || doc.createElement('div') : | |
| {}; | |
| var NS_XHTML = 'http://www.w3.org/1999/xhtml'; | |
| var ELEMENT_NODE = 1; | |
| var TEXT_NODE = 3; | |
| var COMMENT_NODE = 8; | |
| // Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32> | |
| // (IE7+ support) <=IE7 does not support el.hasAttribute(name) | |
| var hasAttributeNS; | |
| if (testEl.hasAttributeNS) { | |
| hasAttributeNS = function(el, namespaceURI, name) { | |
| return el.hasAttributeNS(namespaceURI, name); | |
| }; | |
| } else if (testEl.hasAttribute) { | |
| hasAttributeNS = function(el, namespaceURI, name) { | |
| return el.hasAttribute(name); | |
| }; | |
| } else { | |
| hasAttributeNS = function(el, namespaceURI, name) { | |
| return !!el.getAttributeNode(name); | |
| }; | |
| } | |
| function toElement(str) { | |
| if (!range && doc.createRange) { | |
| range = doc.createRange(); | |
| range.selectNode(doc.body); | |
| } | |
| var fragment; | |
| if (range && range.createContextualFragment) { | |
| fragment = range.createContextualFragment(str); | |
| } else { | |
| fragment = doc.createElement('body'); | |
| fragment.innerHTML = str; | |
| } | |
| return fragment.childNodes[0]; | |
| } | |
| function syncBooleanAttrProp(fromEl, toEl, name) { | |
| if (fromEl[name] !== toEl[name]) { | |
| fromEl[name] = toEl[name]; | |
| if (fromEl[name]) { | |
| fromEl.setAttribute(name, ''); | |
| } else { | |
| fromEl.removeAttribute(name, ''); | |
| } | |
| } | |
| } | |
| var specialElHandlers = { | |
| /** | |
| * Needed for IE. Apparently IE doesn't think that "selected" is an | |
| * attribute when reading over the attributes using selectEl.attributes | |
| */ | |
| OPTION: function(fromEl, toEl) { | |
| syncBooleanAttrProp(fromEl, toEl, 'selected'); | |
| }, | |
| /** | |
| * The "value" attribute is special for the <input> element since it sets | |
| * the initial value. Changing the "value" attribute without changing the | |
| * "value" property will have no effect since it is only used to the set the | |
| * initial value. Similar for the "checked" attribute, and "disabled". | |
| */ | |
| INPUT: function(fromEl, toEl) { | |
| syncBooleanAttrProp(fromEl, toEl, 'checked'); | |
| syncBooleanAttrProp(fromEl, toEl, 'disabled'); | |
| if (fromEl.value !== toEl.value) { | |
| fromEl.value = toEl.value; | |
| } | |
| if (!hasAttributeNS(toEl, null, 'value')) { | |
| fromEl.removeAttribute('value'); | |
| } | |
| }, | |
| TEXTAREA: function(fromEl, toEl) { | |
| var newValue = toEl.value; | |
| if (fromEl.value !== newValue) { | |
| fromEl.value = newValue; | |
| } | |
| if (fromEl.firstChild) { | |
| fromEl.firstChild.nodeValue = newValue; | |
| } | |
| } | |
| }; | |
| function noop() {} | |
| /** | |
| * Returns true if two node's names are the same. | |
| * | |
| * NOTE: We don't bother checking `namespaceURI` because you will never find two HTML elements with the same | |
| * nodeName and different namespace URIs. | |
| * | |
| * @param {Element} a | |
| * @param {Element} b The target element | |
| * @return {boolean} | |
| */ | |
| function compareNodeNames(fromEl, toEl) { | |
| var fromNodeName = fromEl.nodeName; | |
| var toNodeName = toEl.nodeName; | |
| if (fromNodeName === toNodeName) { | |
| return true; | |
| } | |
| if (toEl.actualize && | |
| fromNodeName.charCodeAt(0) < 91 && /* from tag name is upper case */ | |
| toNodeName.charCodeAt(0) > 90 /* target tag name is lower case */) { | |
| // If the target element is a virtual DOM node then we may need to normalize the tag name | |
| // before comparing. Normal HTML elements that are in the "http://www.w3.org/1999/xhtml" | |
| // are converted to upper case | |
| return fromNodeName === toNodeName.toUpperCase(); | |
| } else { | |
| return false; | |
| } | |
| } | |
| /** | |
| * Create an element, optionally with a known namespace URI. | |
| * | |
| * @param {string} name the element name, e.g. 'div' or 'svg' | |
| * @param {string} [namespaceURI] the element's namespace URI, i.e. the value of | |
| * its `xmlns` attribute or its inferred namespace. | |
| * | |
| * @return {Element} | |
| */ | |
| function createElementNS(name, namespaceURI) { | |
| return !namespaceURI || namespaceURI === NS_XHTML ? | |
| doc.createElement(name) : | |
| doc.createElementNS(namespaceURI, name); | |
| } | |
| /** | |
| * Loop over all of the attributes on the target node and make sure the original | |
| * DOM node has the same attributes. If an attribute found on the original node | |
| * is not on the new node then remove it from the original node. | |
| * | |
| * @param {Element} fromNode | |
| * @param {Element} toNode | |
| */ | |
| function morphAttrs(fromNode, toNode) { | |
| var attrs = toNode.attributes; | |
| var i; | |
| var attr; | |
| var attrName; | |
| var attrNamespaceURI; | |
| var attrValue; | |
| var fromValue; | |
| if (toNode.assignAttributes) { | |
| toNode.assignAttributes(fromNode); | |
| } else { | |
| for (i = attrs.length - 1; i >= 0; --i) { | |
| attr = attrs[i]; | |
| attrName = attr.name; | |
| attrNamespaceURI = attr.namespaceURI; | |
| attrValue = attr.value; | |
| if (attrNamespaceURI) { | |
| attrName = attr.localName || attrName; | |
| fromValue = fromNode.getAttributeNS(attrNamespaceURI, attrName); | |
| if (fromValue !== attrValue) { | |
| fromNode.setAttributeNS(attrNamespaceURI, attrName, attrValue); | |
| } | |
| } else { | |
| fromValue = fromNode.getAttribute(attrName); | |
| if (fromValue !== attrValue) { | |
| fromNode.setAttribute(attrName, attrValue); | |
| } | |
| } | |
| } | |
| } | |
| // Remove any extra attributes found on the original DOM element that | |
| // weren't found on the target element. | |
| attrs = fromNode.attributes; | |
| for (i = attrs.length - 1; i >= 0; --i) { | |
| attr = attrs[i]; | |
| if (attr.specified !== false) { | |
| attrName = attr.name; | |
| attrNamespaceURI = attr.namespaceURI; | |
| if (attrNamespaceURI) { | |
| attrName = attr.localName || attrName; | |
| if (!hasAttributeNS(toNode, attrNamespaceURI, attrName)) { | |
| fromNode.removeAttributeNS(attrNamespaceURI, attrName); | |
| } | |
| } else { | |
| if (!hasAttributeNS(toNode, null, attrName)) { | |
| fromNode.removeAttribute(attrName); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Copies the children of one DOM element to another DOM element | |
| */ | |
| function moveChildren(fromEl, toEl) { | |
| var curChild = fromEl.firstChild; | |
| while (curChild) { | |
| var nextChild = curChild.nextSibling; | |
| toEl.appendChild(curChild); | |
| curChild = nextChild; | |
| } | |
| return toEl; | |
| } | |
| function defaultGetNodeKey(node) { | |
| return node.id; | |
| } | |
| function morphdom(fromNode, toNode, options) { | |
| if (!options) { | |
| options = {}; | |
| } | |
| if (typeof toNode === 'string') { | |
| if (fromNode.nodeName === '#document' || fromNode.nodeName === 'HTML') { | |
| var toNodeHtml = toNode; | |
| toNode = doc.createElement('html'); | |
| toNode.innerHTML = toNodeHtml; | |
| } else { | |
| toNode = toElement(toNode); | |
| } | |
| } | |
| var getNodeKey = options.getNodeKey || defaultGetNodeKey; | |
| var onBeforeNodeAdded = options.onBeforeNodeAdded || noop; | |
| var onNodeAdded = options.onNodeAdded || noop; | |
| var onBeforeElUpdated = options.onBeforeElUpdated || noop; | |
| var onElUpdated = options.onElUpdated || noop; | |
| var onBeforeNodeDiscarded = options.onBeforeNodeDiscarded || noop; | |
| var onNodeDiscarded = options.onNodeDiscarded || noop; | |
| var onBeforeElChildrenUpdated = options.onBeforeElChildrenUpdated || noop; | |
| var childrenOnly = options.childrenOnly === true; | |
| // This object is used as a lookup to quickly find all keyed elements in the original DOM tree. | |
| var fromNodesLookup = {}; | |
| var keyedRemovalList; | |
| function addKeyedRemoval(key) { | |
| if (keyedRemovalList) { | |
| keyedRemovalList.push(key); | |
| } else { | |
| keyedRemovalList = [key]; | |
| } | |
| } | |
| function walkDiscardedChildNodes(node, skipKeyedNodes) { | |
| if (node.nodeType === ELEMENT_NODE) { | |
| var curChild = node.firstChild; | |
| while (curChild) { | |
| var key = undefined; | |
| if (skipKeyedNodes && (key = getNodeKey(curChild))) { | |
| // If we are skipping keyed nodes then we add the key | |
| // to a list so that it can be handled at the very end. | |
| addKeyedRemoval(key); | |
| } else { | |
| // Only report the node as discarded if it is not keyed. We do this because | |
| // at the end we loop through all keyed elements that were unmatched | |
| // and then discard them in one final pass. | |
| onNodeDiscarded(curChild); | |
| if (curChild.firstChild) { | |
| walkDiscardedChildNodes(curChild, skipKeyedNodes); | |
| } | |
| } | |
| curChild = curChild.nextSibling; | |
| } | |
| } | |
| } | |
| /** | |
| * Removes a DOM node out of the original DOM | |
| * | |
| * @param {Node} node The node to remove | |
| * @param {Node} parentNode The nodes parent | |
| * @param {Boolean} skipKeyedNodes If true then elements with keys will be skipped and not discarded. | |
| * @return {undefined} | |
| */ | |
| function removeNode(node, parentNode, skipKeyedNodes) { | |
| if (onBeforeNodeDiscarded(node) === false) { | |
| return; | |
| } | |
| if (parentNode) { | |
| parentNode.removeChild(node); | |
| } | |
| onNodeDiscarded(node); | |
| walkDiscardedChildNodes(node, skipKeyedNodes); | |
| } | |
| // // TreeWalker implementation is no faster, but keeping this around in case this changes in the future | |
| // function indexTree(root) { | |
| // var treeWalker = document.createTreeWalker( | |
| // root, | |
| // NodeFilter.SHOW_ELEMENT); | |
| // | |
| // var el; | |
| // while((el = treeWalker.nextNode())) { | |
| // var key = getNodeKey(el); | |
| // if (key) { | |
| // fromNodesLookup[key] = el; | |
| // } | |
| // } | |
| // } | |
| // // NodeIterator implementation is no faster, but keeping this around in case this changes in the future | |
| // | |
| // function indexTree(node) { | |
| // var nodeIterator = document.createNodeIterator(node, NodeFilter.SHOW_ELEMENT); | |
| // var el; | |
| // while((el = nodeIterator.nextNode())) { | |
| // var key = getNodeKey(el); | |
| // if (key) { | |
| // fromNodesLookup[key] = el; | |
| // } | |
| // } | |
| // } | |
| function indexTree(node) { | |
| if (node.nodeType === ELEMENT_NODE) { | |
| var curChild = node.firstChild; | |
| while (curChild) { | |
| var key = getNodeKey(curChild); | |
| if (key) { | |
| fromNodesLookup[key] = curChild; | |
| } | |
| // Walk recursively | |
| indexTree(curChild); | |
| curChild = curChild.nextSibling; | |
| } | |
| } | |
| } | |
| indexTree(fromNode); | |
| function handleNodeAdded(el) { | |
| onNodeAdded(el); | |
| var curChild = el.firstChild; | |
| while (curChild) { | |
| var nextSibling = curChild.nextSibling; | |
| var key = getNodeKey(curChild); | |
| if (key) { | |
| var unmatchedFromEl = fromNodesLookup[key]; | |
| if (unmatchedFromEl && compareNodeNames(curChild, unmatchedFromEl)) { | |
| curChild.parentNode.replaceChild(unmatchedFromEl, curChild); | |
| morphEl(unmatchedFromEl, curChild); | |
| } | |
| } | |
| handleNodeAdded(curChild); | |
| curChild = nextSibling; | |
| } | |
| } | |
| function morphEl(fromEl, toEl, childrenOnly) { | |
| var toElKey = getNodeKey(toEl); | |
| var curFromNodeKey; | |
| if (toElKey) { | |
| // If an element with an ID is being morphed then it is will be in the final | |
| // DOM so clear it out of the saved elements collection | |
| delete fromNodesLookup[toElKey]; | |
| } | |
| if (toNode.isSameNode && toNode.isSameNode(fromNode)) { | |
| return; | |
| } | |
| if (!childrenOnly) { | |
| if (onBeforeElUpdated(fromEl, toEl) === false) { | |
| return; | |
| } | |
| morphAttrs(fromEl, toEl); | |
| onElUpdated(fromEl); | |
| if (onBeforeElChildrenUpdated(fromEl, toEl) === false) { | |
| return; | |
| } | |
| } | |
| if (fromEl.nodeName !== 'TEXTAREA') { | |
| var curToNodeChild = toEl.firstChild; | |
| var curFromNodeChild = fromEl.firstChild; | |
| var curToNodeKey; | |
| var fromNextSibling; | |
| var toNextSibling; | |
| var matchingFromEl; | |
| outer: while (curToNodeChild) { | |
| toNextSibling = curToNodeChild.nextSibling; | |
| curToNodeKey = getNodeKey(curToNodeChild); | |
| while (curFromNodeChild) { | |
| if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) { | |
| return; | |
| } | |
| curFromNodeKey = getNodeKey(curFromNodeChild); | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| var curFromNodeType = curFromNodeChild.nodeType; | |
| var isCompatible = undefined; | |
| if (curFromNodeType === curToNodeChild.nodeType) { | |
| if (curFromNodeType === ELEMENT_NODE) { | |
| // Both nodes being compared are Element nodes | |
| if (curToNodeKey) { | |
| // The target node has a key so we want to match it up with the correct element | |
| // in the original DOM tree | |
| if (curToNodeKey !== curFromNodeKey) { | |
| // The current element in the original DOM tree does not have a matching key so | |
| // let's check our lookup to see if there is a matching element in the original | |
| // DOM tree | |
| if ((matchingFromEl = fromNodesLookup[curToNodeKey])) { | |
| if (curFromNodeChild.nextSibling === matchingFromEl) { | |
| // Special case for single element removals. To avoid removing the original | |
| // DOM node out of the tree (since that can break CSS transitions, etc.), | |
| // we will instead discard the current node and wait until the next | |
| // iteration to properly match up the keyed target element with its matching | |
| // element in the original tree | |
| isCompatible = false; | |
| } else { | |
| // We found a matching keyed element somewhere in the original DOM tree. | |
| // Let's moving the original DOM node into the current position and morph | |
| // it. | |
| // NOTE: We use insertBefore instead of replaceChild because we want to go through | |
| // the `removeNode()` function for the node that is being discarded so that | |
| // all lifecycle hooks are correctly invoked | |
| fromEl.insertBefore(matchingFromEl, curFromNodeChild); | |
| if (curFromNodeKey) { | |
| // Since the node is keyed it might be matched up later so we defer | |
| // the actual removal to later | |
| addKeyedRemoval(curFromNodeKey); | |
| } else { | |
| // NOTE: we skip nested keyed nodes from being removed since there is | |
| // still a chance they will be matched up later | |
| removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */); | |
| } | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| curFromNodeChild = matchingFromEl; | |
| } | |
| } else { | |
| // The nodes are not compatible since the "to" node has a key and there | |
| // is no matching keyed node in the source tree | |
| isCompatible = false; | |
| } | |
| } | |
| } else if (curFromNodeKey) { | |
| // The original has a key | |
| isCompatible = false; | |
| } | |
| isCompatible = isCompatible !== false && compareNodeNames(curFromNodeChild, curToNodeChild); | |
| if (isCompatible) { | |
| // We found compatible DOM elements so transform | |
| // the current "from" node to match the current | |
| // target DOM node. | |
| morphEl(curFromNodeChild, curToNodeChild); | |
| } | |
| } else if (curFromNodeType === TEXT_NODE || curFromNodeType == COMMENT_NODE) { | |
| // Both nodes being compared are Text or Comment nodes | |
| isCompatible = true; | |
| // Simply update nodeValue on the original node to | |
| // change the text value | |
| curFromNodeChild.nodeValue = curToNodeChild.nodeValue; | |
| } | |
| } | |
| if (isCompatible) { | |
| // Advance both the "to" child and the "from" child since we found a match | |
| curToNodeChild = toNextSibling; | |
| curFromNodeChild = fromNextSibling; | |
| continue outer; | |
| } | |
| // No compatible match so remove the old node from the DOM and continue trying to find a | |
| // match in the original DOM. However, we only do this if the from node is not keyed | |
| // since it is possible that a keyed node might match up with a node somewhere else in the | |
| // target tree and we don't want to discard it just yet since it still might find a | |
| // home in the final DOM tree. After everything is done we will remove any keyed nodes | |
| // that didn't find a home | |
| if (curFromNodeKey) { | |
| // Since the node is keyed it might be matched up later so we defer | |
| // the actual removal to later | |
| addKeyedRemoval(curFromNodeKey); | |
| } else { | |
| // NOTE: we skip nested keyed nodes from being removed since there is | |
| // still a chance they will be matched up later | |
| removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */); | |
| } | |
| curFromNodeChild = fromNextSibling; | |
| } | |
| // If we got this far then we did not find a candidate match for | |
| // our "to node" and we exhausted all of the children "from" | |
| // nodes. Therefore, we will just append the current "to" node | |
| // to the end | |
| if (curToNodeKey && (matchingFromEl = fromNodesLookup[curToNodeKey]) && compareNodeNames(matchingFromEl, curToNodeChild)) { | |
| fromEl.appendChild(matchingFromEl); | |
| morphEl(matchingFromEl, curToNodeChild); | |
| } else { | |
| var onBeforeNodeAddedResult = onBeforeNodeAdded(curToNodeChild); | |
| if (onBeforeNodeAddedResult !== false) { | |
| if (onBeforeNodeAddedResult) { | |
| curToNodeChild = onBeforeNodeAddedResult; | |
| } | |
| if (curToNodeChild.actualize) { | |
| curToNodeChild = curToNodeChild.actualize(fromEl.ownerDocument || doc); | |
| } | |
| fromEl.appendChild(curToNodeChild); | |
| handleNodeAdded(curToNodeChild); | |
| } | |
| } | |
| curToNodeChild = toNextSibling; | |
| curFromNodeChild = fromNextSibling; | |
| } | |
| // We have processed all of the "to nodes". If curFromNodeChild is | |
| // non-null then we still have some from nodes left over that need | |
| // to be removed | |
| while (curFromNodeChild) { | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| if ((curFromNodeKey = getNodeKey(curFromNodeChild))) { | |
| // Since the node is keyed it might be matched up later so we defer | |
| // the actual removal to later | |
| addKeyedRemoval(curFromNodeKey); | |
| } else { | |
| // NOTE: we skip nested keyed nodes from being removed since there is | |
| // still a chance they will be matched up later | |
| removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */); | |
| } | |
| curFromNodeChild = fromNextSibling; | |
| } | |
| } | |
| var specialElHandler = specialElHandlers[fromEl.nodeName]; | |
| if (specialElHandler) { | |
| specialElHandler(fromEl, toEl); | |
| } | |
| } // END: morphEl(...) | |
| var morphedNode = fromNode; | |
| var morphedNodeType = morphedNode.nodeType; | |
| var toNodeType = toNode.nodeType; | |
| if (!childrenOnly) { | |
| // Handle the case where we are given two DOM nodes that are not | |
| // compatible (e.g. <div> --> <span> or <div> --> TEXT) | |
| if (morphedNodeType === ELEMENT_NODE) { | |
| if (toNodeType === ELEMENT_NODE) { | |
| if (!compareNodeNames(fromNode, toNode)) { | |
| onNodeDiscarded(fromNode); | |
| morphedNode = moveChildren(fromNode, createElementNS(toNode.nodeName, toNode.namespaceURI)); | |
| } | |
| } else { | |
| // Going from an element node to a text node | |
| morphedNode = toNode; | |
| } | |
| } else if (morphedNodeType === TEXT_NODE || morphedNodeType === COMMENT_NODE) { // Text or comment node | |
| if (toNodeType === morphedNodeType) { | |
| morphedNode.nodeValue = toNode.nodeValue; | |
| return morphedNode; | |
| } else { | |
| // Text node to something else | |
| morphedNode = toNode; | |
| } | |
| } | |
| } | |
| if (morphedNode === toNode) { | |
| // The "to node" was not compatible with the "from node" so we had to | |
| // toss out the "from node" and use the "to node" | |
| onNodeDiscarded(fromNode); | |
| } else { | |
| morphEl(morphedNode, toNode, childrenOnly); | |
| // We now need to loop over any keyed nodes that might need to be | |
| // removed. We only do the removal if we know that the keyed node | |
| // never found a match. When a keyed node is matched up we remove | |
| // it out of fromNodesLookup and we use fromNodesLookup to determine | |
| // if a keyed node has been matched up or not | |
| if (keyedRemovalList) { | |
| for (var i=0, len=keyedRemovalList.length; i<len; i++) { | |
| var elToRemove = fromNodesLookup[keyedRemovalList[i]]; | |
| if (elToRemove) { | |
| removeNode(elToRemove, elToRemove.parentNode, false); | |
| } | |
| } | |
| } | |
| } | |
| if (!childrenOnly && morphedNode !== fromNode && fromNode.parentNode) { | |
| if (morphedNode.actualize) { | |
| morphedNode = morphedNode.actualize(fromNode.ownerDocument || doc); | |
| } | |
| // If we had to swap out the from node with a new node because the old | |
| // node was not compatible with the target node then we need to | |
| // replace the old DOM node in the original DOM tree. This is only | |
| // possible if the original DOM node was part of a DOM tree which | |
| // we know is the case if it has a parent node. | |
| fromNode.parentNode.replaceChild(morphedNode, fromNode); | |
| } | |
| return morphedNode; | |
| } | |
| module.exports = morphdom; | |
| },{}],9:[function(require,module,exports){ | |
| module.exports = [ | |
| // attribute events (can be set with attributes) | |
| 'onclick', | |
| 'ondblclick', | |
| 'onmousedown', | |
| 'onmouseup', | |
| 'onmouseover', | |
| 'onmousemove', | |
| 'onmouseout', | |
| 'ondragstart', | |
| 'ondrag', | |
| 'ondragenter', | |
| 'ondragleave', | |
| 'ondragover', | |
| 'ondrop', | |
| 'ondragend', | |
| 'onkeydown', | |
| 'onkeypress', | |
| 'onkeyup', | |
| 'onunload', | |
| 'onabort', | |
| 'onerror', | |
| 'onresize', | |
| 'onscroll', | |
| 'onselect', | |
| 'onchange', | |
| 'onsubmit', | |
| 'onreset', | |
| 'onfocus', | |
| 'onblur', | |
| 'oninput', | |
| // other common events | |
| 'oncontextmenu', | |
| 'onfocusin', | |
| 'onfocusout' | |
| ] | |
| },{}],"yo-yo":[function(require,module,exports){ | |
| var bel = require('bel') // turns template tag into DOM elements | |
| var morphdom = require('morphdom') // efficiently diffs + morphs two DOM elements | |
| var defaultEvents = require('./update-events.js') // default events to be copied when dom elements update | |
| module.exports = bel | |
| // TODO move this + defaultEvents to a new module once we receive more feedback | |
| module.exports.update = function (fromNode, toNode, opts) { | |
| if (!opts) opts = {} | |
| if (opts.events !== false) { | |
| if (!opts.onBeforeElUpdated) opts.onBeforeElUpdated = copier | |
| } | |
| return morphdom(fromNode, toNode, opts) | |
| // morphdom only copies attributes. we decided we also wanted to copy events | |
| // that can be set via attributes | |
| function copier (f, t) { | |
| // copy events: | |
| var events = opts.events || defaultEvents | |
| for (var i = 0; i < events.length; i++) { | |
| var ev = events[i] | |
| if (t[ev]) { // if new element has a whitelisted attribute | |
| f[ev] = t[ev] // update existing element | |
| } else if (f[ev]) { // if existing element has it and new one doesnt | |
| f[ev] = undefined // remove it from existing element | |
| } | |
| } | |
| // copy values for form elements | |
| if ((f.nodeName === 'INPUT' && f.type !== 'file') || f.nodeName === 'TEXTAREA' || f.nodeName === 'SELECT') { | |
| if (t.getAttribute('value') === null) t.value = f.value | |
| } | |
| } | |
| } | |
| },{"./update-events.js":9,"bel":2,"morphdom":8}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-resolve/empty.js","node_modules/bel/index.js","node_modules/bel/node_modules/global/document.js","node_modules/bel/node_modules/global/window.js","node_modules/bel/node_modules/hyperx/index.js","node_modules/bel/node_modules/hyperx/node_modules/hyperscript-attribute-to-property/index.js","node_modules/bel/node_modules/on-load/index.js","node_modules/morphdom/src/index.js","update-events.js","index.js"],"names":[],"mappings":"AAAA;ACAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxoBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})",null,"var document = require('global/document')\nvar hyperx = require('hyperx')\nvar onload = require('on-load')\n\nvar SVGNS = 'http://www.w3.org/2000/svg'\nvar BOOL_PROPS = {\n  autofocus: 1,\n  checked: 1,\n  defaultchecked: 1,\n  disabled: 1,\n  formnovalidate: 1,\n  indeterminate: 1,\n  readonly: 1,\n  required: 1,\n  selected: 1,\n  willvalidate: 1\n}\nvar SVG_TAGS = [\n  'svg',\n  'altGlyph', 'altGlyphDef', 'altGlyphItem', 'animate', 'animateColor',\n  'animateMotion', 'animateTransform', 'circle', 'clipPath', 'color-profile',\n  'cursor', 'defs', 'desc', 'ellipse', 'feBlend', 'feColorMatrix',\n  'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting',\n  'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB',\n  'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode',\n  'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting',\n  'feSpotLight', 'feTile', 'feTurbulence', 'filter', 'font', 'font-face',\n  'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri',\n  'foreignObject', 'g', 'glyph', 'glyphRef', 'hkern', 'image', 'line',\n  'linearGradient', 'marker', 'mask', 'metadata', 'missing-glyph', 'mpath',\n  'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect',\n  'set', 'stop', 'switch', 'symbol', 'text', 'textPath', 'title', 'tref',\n  'tspan', 'use', 'view', 'vkern'\n]\n\nfunction belCreateElement (tag, props, children) {\n  var el\n\n  // If an svg tag, it needs a namespace\n  if (SVG_TAGS.indexOf(tag) !== -1) {\n    props.namespace = SVGNS\n  }\n\n  // If we are using a namespace\n  var ns = false\n  if (props.namespace) {\n    ns = props.namespace\n    delete props.namespace\n  }\n\n  // Create the element\n  if (ns) {\n    el = document.createElementNS(ns, tag)\n  } else {\n    el = document.createElement(tag)\n  }\n\n  // If adding onload events\n  if (props.onload || props.onunload) {\n    var load = props.onload || function () {}\n    var unload = props.onunload || function () {}\n    onload(el, function bel_onload () {\n      load(el)\n    }, function bel_onunload () {\n      unload(el)\n    },\n    // We have to use non-standard `caller` to find who invokes `belCreateElement`\n    belCreateElement.caller.caller.caller)\n    delete props.onload\n    delete props.onunload\n  }\n\n  // Create the properties\n  for (var p in props) {\n    if (props.hasOwnProperty(p)) {\n      var key = p.toLowerCase()\n      var val = props[p]\n      // Normalize className\n      if (key === 'classname') {\n        key = 'class'\n        p = 'class'\n      }\n      // The for attribute gets transformed to htmlFor, but we just set as for\n      if (p === 'htmlFor') {\n        p = 'for'\n      }\n      // If a property is boolean, set itself to the key\n      if (BOOL_PROPS[key]) {\n        if (val === 'true') val = key\n        else if (val === 'false') continue\n      }\n      // If a property prefers being set directly vs setAttribute\n      if (key.slice(0, 2) === 'on') {\n        el[p] = val\n      } else {\n        if (ns) {\n          el.setAttributeNS(null, p, val)\n        } else {\n          el.setAttribute(p, val)\n        }\n      }\n    }\n  }\n\n  function appendChild (childs) {\n    if (!Array.isArray(childs)) return\n    for (var i = 0; i < childs.length; i++) {\n      var node = childs[i]\n      if (Array.isArray(node)) {\n        appendChild(node)\n        continue\n      }\n\n      if (typeof node === 'number' ||\n        typeof node === 'boolean' ||\n        node instanceof Date ||\n        node instanceof RegExp) {\n        node = node.toString()\n      }\n\n      if (typeof node === 'string') {\n        if (el.lastChild && el.lastChild.nodeName === '#text') {\n          el.lastChild.nodeValue += node\n          continue\n        }\n        node = document.createTextNode(node)\n      }\n\n      if (node && node.nodeType) {\n        el.appendChild(node)\n      }\n    }\n  }\n  appendChild(children)\n\n  return el\n}\n\nmodule.exports = hyperx(belCreateElement)\nmodule.exports.createElement = belCreateElement\n","(function (global){\nvar topLevel = typeof global !== 'undefined' ? global :\n    typeof window !== 'undefined' ? window : {}\nvar minDoc = require('min-document');\n\nif (typeof document !== 'undefined') {\n    module.exports = document;\n} else {\n    var doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];\n\n    if (!doccy) {\n        doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;\n    }\n\n    module.exports = doccy;\n}\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9iZWwvbm9kZV9tb2R1bGVzL2dsb2JhbC9kb2N1bWVudC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EiLCJmaWxlIjoiZ2VuZXJhdGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXNDb250ZW50IjpbInZhciB0b3BMZXZlbCA9IHR5cGVvZiBnbG9iYWwgIT09ICd1bmRlZmluZWQnID8gZ2xvYmFsIDpcbiAgICB0eXBlb2Ygd2luZG93ICE9PSAndW5kZWZpbmVkJyA/IHdpbmRvdyA6IHt9XG52YXIgbWluRG9jID0gcmVxdWlyZSgnbWluLWRvY3VtZW50Jyk7XG5cbmlmICh0eXBlb2YgZG9jdW1lbnQgIT09ICd1bmRlZmluZWQnKSB7XG4gICAgbW9kdWxlLmV4cG9ydHMgPSBkb2N1bWVudDtcbn0gZWxzZSB7XG4gICAgdmFyIGRvY2N5ID0gdG9wTGV2ZWxbJ19fR0xPQkFMX0RPQ1VNRU5UX0NBQ0hFQDQnXTtcblxuICAgIGlmICghZG9jY3kpIHtcbiAgICAgICAgZG9jY3kgPSB0b3BMZXZlbFsnX19HTE9CQUxfRE9DVU1FTlRfQ0FDSEVANCddID0gbWluRG9jO1xuICAgIH1cblxuICAgIG1vZHVsZS5leHBvcnRzID0gZG9jY3k7XG59XG4iXX0=","(function (global){\nif (typeof window !== \"undefined\") {\n    module.exports = window;\n} else if (typeof global !== \"undefined\") {\n    module.exports = global;\n} else if (typeof self !== \"undefined\"){\n    module.exports = self;\n} else {\n    module.exports = {};\n}\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9iZWwvbm9kZV9tb2R1bGVzL2dsb2JhbC93aW5kb3cuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpZiAodHlwZW9mIHdpbmRvdyAhPT0gXCJ1bmRlZmluZWRcIikge1xuICAgIG1vZHVsZS5leHBvcnRzID0gd2luZG93O1xufSBlbHNlIGlmICh0eXBlb2YgZ2xvYmFsICE9PSBcInVuZGVmaW5lZFwiKSB7XG4gICAgbW9kdWxlLmV4cG9ydHMgPSBnbG9iYWw7XG59IGVsc2UgaWYgKHR5cGVvZiBzZWxmICE9PSBcInVuZGVmaW5lZFwiKXtcbiAgICBtb2R1bGUuZXhwb3J0cyA9IHNlbGY7XG59IGVsc2Uge1xuICAgIG1vZHVsZS5leHBvcnRzID0ge307XG59XG4iXX0=","var attrToProp = require('hyperscript-attribute-to-property')\n\nvar VAR = 0, TEXT = 1, OPEN = 2, CLOSE = 3, ATTR = 4\nvar ATTR_KEY = 5, ATTR_KEY_W = 6\nvar ATTR_VALUE_W = 7, ATTR_VALUE = 8\nvar ATTR_VALUE_SQ = 9, ATTR_VALUE_DQ = 10\nvar ATTR_EQ = 11, ATTR_BREAK = 12\n\nmodule.exports = function (h, opts) {\n  h = attrToProp(h)\n  if (!opts) opts = {}\n  var concat = opts.concat || function (a, b) {\n    return String(a) + String(b)\n  }\n\n  return function (strings) {\n    var state = TEXT, reg = ''\n    var arglen = arguments.length\n    var parts = []\n\n    for (var i = 0; i < strings.length; i++) {\n      if (i < arglen - 1) {\n        var arg = arguments[i+1]\n        var p = parse(strings[i])\n        var xstate = state\n        if (xstate === ATTR_VALUE_DQ) xstate = ATTR_VALUE\n        if (xstate === ATTR_VALUE_SQ) xstate = ATTR_VALUE\n        if (xstate === ATTR_VALUE_W) xstate = ATTR_VALUE\n        if (xstate === ATTR) xstate = ATTR_KEY\n        p.push([ VAR, xstate, arg ])\n        parts.push.apply(parts, p)\n      } else parts.push.apply(parts, parse(strings[i]))\n    }\n\n    var tree = [null,{},[]]\n    var stack = [[tree,-1]]\n    for (var i = 0; i < parts.length; i++) {\n      var cur = stack[stack.length-1][0]\n      var p = parts[i], s = p[0]\n      if (s === OPEN && /^\\//.test(p[1])) {\n        var ix = stack[stack.length-1][1]\n        if (stack.length > 1) {\n          stack.pop()\n          stack[stack.length-1][0][2][ix] = h(\n            cur[0], cur[1], cur[2].length ? cur[2] : undefined\n          )\n        }\n      } else if (s === OPEN) {\n        var c = [p[1],{},[]]\n        cur[2].push(c)\n        stack.push([c,cur[2].length-1])\n      } else if (s === ATTR_KEY || (s === VAR && p[1] === ATTR_KEY)) {\n        var key = ''\n        var copyKey\n        for (; i < parts.length; i++) {\n          if (parts[i][0] === ATTR_KEY) {\n            key = concat(key, parts[i][1])\n          } else if (parts[i][0] === VAR && parts[i][1] === ATTR_KEY) {\n            if (typeof parts[i][2] === 'object' && !key) {\n              for (copyKey in parts[i][2]) {\n                if (parts[i][2].hasOwnProperty(copyKey) && !cur[1][copyKey]) {\n                  cur[1][copyKey] = parts[i][2][copyKey]\n                }\n              }\n            } else {\n              key = concat(key, parts[i][2])\n            }\n          } else break\n        }\n        if (parts[i][0] === ATTR_EQ) i++\n        var j = i\n        for (; i < parts.length; i++) {\n          if (parts[i][0] === ATTR_VALUE || parts[i][0] === ATTR_KEY) {\n            if (!cur[1][key]) cur[1][key] = strfn(parts[i][1])\n            else cur[1][key] = concat(cur[1][key], parts[i][1])\n          } else if (parts[i][0] === VAR\n          && (parts[i][1] === ATTR_VALUE || parts[i][1] === ATTR_KEY)) {\n            if (!cur[1][key]) cur[1][key] = strfn(parts[i][2])\n            else cur[1][key] = concat(cur[1][key], parts[i][2])\n          } else {\n            if (key.length && !cur[1][key] && i === j\n            && (parts[i][0] === CLOSE || parts[i][0] === ATTR_BREAK)) {\n              // https://html.spec.whatwg.org/multipage/infrastructure.html#boolean-attributes\n              // empty string is falsy, not well behaved value in browser\n              cur[1][key] = key.toLowerCase()\n            }\n            break\n          }\n        }\n      } else if (s === ATTR_KEY) {\n        cur[1][p[1]] = true\n      } else if (s === VAR && p[1] === ATTR_KEY) {\n        cur[1][p[2]] = true\n      } else if (s === CLOSE) {\n        if (selfClosing(cur[0]) && stack.length) {\n          var ix = stack[stack.length-1][1]\n          stack.pop()\n          stack[stack.length-1][0][2][ix] = h(\n            cur[0], cur[1], cur[2].length ? cur[2] : undefined\n          )\n        }\n      } else if (s === VAR && p[1] === TEXT) {\n        if (p[2] === undefined || p[2] === null) p[2] = ''\n        else if (!p[2]) p[2] = concat('', p[2])\n        if (Array.isArray(p[2][0])) {\n          cur[2].push.apply(cur[2], p[2])\n        } else {\n          cur[2].push(p[2])\n        }\n      } else if (s === TEXT) {\n        cur[2].push(p[1])\n      } else if (s === ATTR_EQ || s === ATTR_BREAK) {\n        // no-op\n      } else {\n        throw new Error('unhandled: ' + s)\n      }\n    }\n\n    if (tree[2].length > 1 && /^\\s*$/.test(tree[2][0])) {\n      tree[2].shift()\n    }\n\n    if (tree[2].length > 2\n    || (tree[2].length === 2 && /\\S/.test(tree[2][1]))) {\n      throw new Error(\n        'multiple root elements must be wrapped in an enclosing tag'\n      )\n    }\n    if (Array.isArray(tree[2][0]) && typeof tree[2][0][0] === 'string'\n    && Array.isArray(tree[2][0][2])) {\n      tree[2][0] = h(tree[2][0][0], tree[2][0][1], tree[2][0][2])\n    }\n    return tree[2][0]\n\n    function parse (str) {\n      var res = []\n      if (state === ATTR_VALUE_W) state = ATTR\n      for (var i = 0; i < str.length; i++) {\n        var c = str.charAt(i)\n        if (state === TEXT && c === '<') {\n          if (reg.length) res.push([TEXT, reg])\n          reg = ''\n          state = OPEN\n        } else if (c === '>' && !quot(state)) {\n          if (state === OPEN) {\n            res.push([OPEN,reg])\n          } else if (state === ATTR_KEY) {\n            res.push([ATTR_KEY,reg])\n          } else if (state === ATTR_VALUE && reg.length) {\n            res.push([ATTR_VALUE,reg])\n          }\n          res.push([CLOSE])\n          reg = ''\n          state = TEXT\n        } else if (state === TEXT) {\n          reg += c\n        } else if (state === OPEN && /\\s/.test(c)) {\n          res.push([OPEN, reg])\n          reg = ''\n          state = ATTR\n        } else if (state === OPEN) {\n          reg += c\n        } else if (state === ATTR && /[\\w-]/.test(c)) {\n          state = ATTR_KEY\n          reg = c\n        } else if (state === ATTR && /\\s/.test(c)) {\n          if (reg.length) res.push([ATTR_KEY,reg])\n          res.push([ATTR_BREAK])\n        } else if (state === ATTR_KEY && /\\s/.test(c)) {\n          res.push([ATTR_KEY,reg])\n          reg = ''\n          state = ATTR_KEY_W\n        } else if (state === ATTR_KEY && c === '=') {\n          res.push([ATTR_KEY,reg],[ATTR_EQ])\n          reg = ''\n          state = ATTR_VALUE_W\n        } else if (state === ATTR_KEY) {\n          reg += c\n        } else if ((state === ATTR_KEY_W || state === ATTR) && c === '=') {\n          res.push([ATTR_EQ])\n          state = ATTR_VALUE_W\n        } else if ((state === ATTR_KEY_W || state === ATTR) && !/\\s/.test(c)) {\n          res.push([ATTR_BREAK])\n          if (/[\\w-]/.test(c)) {\n            reg += c\n            state = ATTR_KEY\n          } else state = ATTR\n        } else if (state === ATTR_VALUE_W && c === '\"') {\n          state = ATTR_VALUE_DQ\n        } else if (state === ATTR_VALUE_W && c === \"'\") {\n          state = ATTR_VALUE_SQ\n        } else if (state === ATTR_VALUE_DQ && c === '\"') {\n          res.push([ATTR_VALUE,reg],[ATTR_BREAK])\n          reg = ''\n          state = ATTR\n        } else if (state === ATTR_VALUE_SQ && c === \"'\") {\n          res.push([ATTR_VALUE,reg],[ATTR_BREAK])\n          reg = ''\n          state = ATTR\n        } else if (state === ATTR_VALUE_W && !/\\s/.test(c)) {\n          state = ATTR_VALUE\n          i--\n        } else if (state === ATTR_VALUE && /\\s/.test(c)) {\n          res.push([ATTR_VALUE,reg],[ATTR_BREAK])\n          reg = ''\n          state = ATTR\n        } else if (state === ATTR_VALUE || state === ATTR_VALUE_SQ\n        || state === ATTR_VALUE_DQ) {\n          reg += c\n        }\n      }\n      if (state === TEXT && reg.length) {\n        res.push([TEXT,reg])\n        reg = ''\n      } else if (state === ATTR_VALUE && reg.length) {\n        res.push([ATTR_VALUE,reg])\n        reg = ''\n      } else if (state === ATTR_VALUE_DQ && reg.length) {\n        res.push([ATTR_VALUE,reg])\n        reg = ''\n      } else if (state === ATTR_VALUE_SQ && reg.length) {\n        res.push([ATTR_VALUE,reg])\n        reg = ''\n      } else if (state === ATTR_KEY) {\n        res.push([ATTR_KEY,reg])\n        reg = ''\n      }\n      return res\n    }\n  }\n\n  function strfn (x) {\n    if (typeof x === 'function') return x\n    else if (typeof x === 'string') return x\n    else if (x && typeof x === 'object') return x\n    else return concat('', x)\n  }\n}\n\nfunction quot (state) {\n  return state === ATTR_VALUE_SQ || state === ATTR_VALUE_DQ\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty\nfunction has (obj, key) { return hasOwn.call(obj, key) }\n\nvar closeRE = RegExp('^(' + [\n  'area', 'base', 'basefont', 'bgsound', 'br', 'col', 'command', 'embed',\n  'frame', 'hr', 'img', 'input', 'isindex', 'keygen', 'link', 'meta', 'param',\n  'source', 'track', 'wbr',\n  // SVG TAGS\n  'animate', 'animateTransform', 'circle', 'cursor', 'desc', 'ellipse',\n  'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite',\n  'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap',\n  'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR',\n  'feGaussianBlur', 'feImage', 'feMergeNode', 'feMorphology',\n  'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile',\n  'feTurbulence', 'font-face-format', 'font-face-name', 'font-face-uri',\n  'glyph', 'glyphRef', 'hkern', 'image', 'line', 'missing-glyph', 'mpath',\n  'path', 'polygon', 'polyline', 'rect', 'set', 'stop', 'tref', 'use', 'view',\n  'vkern'\n].join('|') + ')(?:[\\.#][a-zA-Z0-9\\u007F-\\uFFFF_:-]+)*$')\nfunction selfClosing (tag) { return closeRE.test(tag) }\n","module.exports = attributeToProperty\n\nvar transform = {\n  'class': 'className',\n  'for': 'htmlFor',\n  'http-equiv': 'httpEquiv'\n}\n\nfunction attributeToProperty (h) {\n  return function (tagName, attrs, children) {\n    for (var attr in attrs) {\n      if (attr in transform) {\n        attrs[transform[attr]] = attrs[attr]\n        delete attrs[attr]\n      }\n    }\n    return h(tagName, attrs, children)\n  }\n}\n","/* global MutationObserver */\nvar document = require('global/document')\nvar window = require('global/window')\nvar watch = Object.create(null)\nvar KEY_ID = 'onloadid' + (new Date() % 9e6).toString(36)\nvar KEY_ATTR = 'data-' + KEY_ID\nvar INDEX = 0\n\nif (window && window.MutationObserver) {\n  var observer = new MutationObserver(function (mutations) {\n    if (Object.keys(watch).length < 1) return\n    for (var i = 0; i < mutations.length; i++) {\n      if (mutations[i].attributeName === KEY_ATTR) {\n        eachAttr(mutations[i], turnon, turnoff)\n        continue\n      }\n      eachMutation(mutations[i].removedNodes, turnoff)\n      eachMutation(mutations[i].addedNodes, turnon)\n    }\n  })\n  observer.observe(document.body, {\n    childList: true,\n    subtree: true,\n    attributes: true,\n    attributeOldValue: true,\n    attributeFilter: [KEY_ATTR]\n  })\n}\n\nmodule.exports = function onload (el, on, off, caller) {\n  on = on || function () {}\n  off = off || function () {}\n  el.setAttribute(KEY_ATTR, 'o' + INDEX)\n  watch['o' + INDEX] = [on, off, 0, caller || onload.caller]\n  INDEX += 1\n  return el\n}\n\nfunction turnon (index, el) {\n  if (watch[index][0] && watch[index][2] === 0) {\n    watch[index][0](el)\n    watch[index][2] = 1\n  }\n}\n\nfunction turnoff (index, el) {\n  if (watch[index][1] && watch[index][2] === 1) {\n    watch[index][1](el)\n    watch[index][2] = 0\n  }\n}\n\nfunction eachAttr (mutation, on, off) {\n  var newValue = mutation.target.getAttribute(KEY_ATTR)\n  if (sameOrigin(mutation.oldValue, newValue)) {\n    watch[newValue] = watch[mutation.oldValue]\n    return\n  }\n  if (watch[mutation.oldValue]) {\n    off(mutation.oldValue, mutation.target)\n  }\n  if (watch[newValue]) {\n    on(newValue, mutation.target)\n  }\n}\n\nfunction sameOrigin (oldValue, newValue) {\n  if (!oldValue || !newValue) return false\n  return watch[oldValue][3] === watch[newValue][3]\n}\n\nfunction eachMutation (nodes, fn) {\n  var keys = Object.keys(watch)\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i] && nodes[i].getAttribute && nodes[i].getAttribute(KEY_ATTR)) {\n      var onloadid = nodes[i].getAttribute(KEY_ATTR)\n      keys.forEach(function (k) {\n        if (onloadid === k) {\n          fn(k, nodes[i])\n        }\n      })\n    }\n    if (nodes[i].childNodes.length > 0) {\n      eachMutation(nodes[i].childNodes, fn)\n    }\n  }\n}\n","'use strict';\n// Create a range object for efficently rendering strings to elements.\nvar range;\n\nvar doc = typeof document !== 'undefined' && document;\n\nvar testEl = doc ?\n    doc.body || doc.createElement('div') :\n    {};\n\nvar NS_XHTML = 'http://www.w3.org/1999/xhtml';\n\nvar ELEMENT_NODE = 1;\nvar TEXT_NODE = 3;\nvar COMMENT_NODE = 8;\n\n// Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32>\n// (IE7+ support) <=IE7 does not support el.hasAttribute(name)\nvar hasAttributeNS;\n\nif (testEl.hasAttributeNS) {\n    hasAttributeNS = function(el, namespaceURI, name) {\n        return el.hasAttributeNS(namespaceURI, name);\n    };\n} else if (testEl.hasAttribute) {\n    hasAttributeNS = function(el, namespaceURI, name) {\n        return el.hasAttribute(name);\n    };\n} else {\n    hasAttributeNS = function(el, namespaceURI, name) {\n        return !!el.getAttributeNode(name);\n    };\n}\n\nfunction toElement(str) {\n    if (!range && doc.createRange) {\n        range = doc.createRange();\n        range.selectNode(doc.body);\n    }\n\n    var fragment;\n    if (range && range.createContextualFragment) {\n        fragment = range.createContextualFragment(str);\n    } else {\n        fragment = doc.createElement('body');\n        fragment.innerHTML = str;\n    }\n    return fragment.childNodes[0];\n}\n\nfunction syncBooleanAttrProp(fromEl, toEl, name) {\n    if (fromEl[name] !== toEl[name]) {\n        fromEl[name] = toEl[name];\n        if (fromEl[name]) {\n            fromEl.setAttribute(name, '');\n        } else {\n            fromEl.removeAttribute(name, '');\n        }\n    }\n}\n\nvar specialElHandlers = {\n    /**\n     * Needed for IE. Apparently IE doesn't think that \"selected\" is an\n     * attribute when reading over the attributes using selectEl.attributes\n     */\n    OPTION: function(fromEl, toEl) {\n        syncBooleanAttrProp(fromEl, toEl, 'selected');\n    },\n    /**\n     * The \"value\" attribute is special for the <input> element since it sets\n     * the initial value. Changing the \"value\" attribute without changing the\n     * \"value\" property will have no effect since it is only used to the set the\n     * initial value.  Similar for the \"checked\" attribute, and \"disabled\".\n     */\n    INPUT: function(fromEl, toEl) {\n        syncBooleanAttrProp(fromEl, toEl, 'checked');\n        syncBooleanAttrProp(fromEl, toEl, 'disabled');\n\n        if (fromEl.value !== toEl.value) {\n            fromEl.value = toEl.value;\n        }\n\n        if (!hasAttributeNS(toEl, null, 'value')) {\n            fromEl.removeAttribute('value');\n        }\n    },\n\n    TEXTAREA: function(fromEl, toEl) {\n        var newValue = toEl.value;\n        if (fromEl.value !== newValue) {\n            fromEl.value = newValue;\n        }\n\n        if (fromEl.firstChild) {\n            fromEl.firstChild.nodeValue = newValue;\n        }\n    }\n};\n\nfunction noop() {}\n\n/**\n * Returns true if two node's names are the same.\n *\n * NOTE: We don't bother checking `namespaceURI` because you will never find two HTML elements with the same\n *       nodeName and different namespace URIs.\n *\n * @param {Element} a\n * @param {Element} b The target element\n * @return {boolean}\n */\nfunction compareNodeNames(fromEl, toEl) {\n    var fromNodeName = fromEl.nodeName;\n    var toNodeName = toEl.nodeName;\n\n    if (fromNodeName === toNodeName) {\n        return true;\n    }\n\n    if (toEl.actualize &&\n        fromNodeName.charCodeAt(0) < 91 && /* from tag name is upper case */\n        toNodeName.charCodeAt(0) > 90 /* target tag name is lower case */) {\n        // If the target element is a virtual DOM node then we may need to normalize the tag name\n        // before comparing. Normal HTML elements that are in the \"http://www.w3.org/1999/xhtml\"\n        // are converted to upper case\n        return fromNodeName === toNodeName.toUpperCase();\n    } else {\n        return false;\n    }\n}\n\n/**\n * Create an element, optionally with a known namespace URI.\n *\n * @param {string} name the element name, e.g. 'div' or 'svg'\n * @param {string} [namespaceURI] the element's namespace URI, i.e. the value of\n * its `xmlns` attribute or its inferred namespace.\n *\n * @return {Element}\n */\nfunction createElementNS(name, namespaceURI) {\n    return !namespaceURI || namespaceURI === NS_XHTML ?\n        doc.createElement(name) :\n        doc.createElementNS(namespaceURI, name);\n}\n\n/**\n * Loop over all of the attributes on the target node and make sure the original\n * DOM node has the same attributes. If an attribute found on the original node\n * is not on the new node then remove it from the original node.\n *\n * @param  {Element} fromNode\n * @param  {Element} toNode\n */\nfunction morphAttrs(fromNode, toNode) {\n    var attrs = toNode.attributes;\n    var i;\n    var attr;\n    var attrName;\n    var attrNamespaceURI;\n    var attrValue;\n    var fromValue;\n\n    if (toNode.assignAttributes) {\n        toNode.assignAttributes(fromNode);\n    } else {\n        for (i = attrs.length - 1; i >= 0; --i) {\n            attr = attrs[i];\n            attrName = attr.name;\n            attrNamespaceURI = attr.namespaceURI;\n            attrValue = attr.value;\n\n            if (attrNamespaceURI) {\n                attrName = attr.localName || attrName;\n                fromValue = fromNode.getAttributeNS(attrNamespaceURI, attrName);\n\n                if (fromValue !== attrValue) {\n                    fromNode.setAttributeNS(attrNamespaceURI, attrName, attrValue);\n                }\n            } else {\n                fromValue = fromNode.getAttribute(attrName);\n\n                if (fromValue !== attrValue) {\n                    fromNode.setAttribute(attrName, attrValue);\n                }\n            }\n        }\n    }\n\n    // Remove any extra attributes found on the original DOM element that\n    // weren't found on the target element.\n    attrs = fromNode.attributes;\n\n    for (i = attrs.length - 1; i >= 0; --i) {\n        attr = attrs[i];\n        if (attr.specified !== false) {\n            attrName = attr.name;\n            attrNamespaceURI = attr.namespaceURI;\n\n            if (attrNamespaceURI) {\n                attrName = attr.localName || attrName;\n\n                if (!hasAttributeNS(toNode, attrNamespaceURI, attrName)) {\n                    fromNode.removeAttributeNS(attrNamespaceURI, attrName);\n                }\n            } else {\n                if (!hasAttributeNS(toNode, null, attrName)) {\n                    fromNode.removeAttribute(attrName);\n                }\n            }\n        }\n    }\n}\n\n/**\n * Copies the children of one DOM element to another DOM element\n */\nfunction moveChildren(fromEl, toEl) {\n    var curChild = fromEl.firstChild;\n    while (curChild) {\n        var nextChild = curChild.nextSibling;\n        toEl.appendChild(curChild);\n        curChild = nextChild;\n    }\n    return toEl;\n}\n\nfunction defaultGetNodeKey(node) {\n    return node.id;\n}\n\nfunction morphdom(fromNode, toNode, options) {\n    if (!options) {\n        options = {};\n    }\n\n    if (typeof toNode === 'string') {\n        if (fromNode.nodeName === '#document' || fromNode.nodeName === 'HTML') {\n            var toNodeHtml = toNode;\n            toNode = doc.createElement('html');\n            toNode.innerHTML = toNodeHtml;\n        } else {\n            toNode = toElement(toNode);\n        }\n    }\n\n    var getNodeKey = options.getNodeKey || defaultGetNodeKey;\n    var onBeforeNodeAdded = options.onBeforeNodeAdded || noop;\n    var onNodeAdded = options.onNodeAdded || noop;\n    var onBeforeElUpdated = options.onBeforeElUpdated || noop;\n    var onElUpdated = options.onElUpdated || noop;\n    var onBeforeNodeDiscarded = options.onBeforeNodeDiscarded || noop;\n    var onNodeDiscarded = options.onNodeDiscarded || noop;\n    var onBeforeElChildrenUpdated = options.onBeforeElChildrenUpdated || noop;\n    var childrenOnly = options.childrenOnly === true;\n\n    // This object is used as a lookup to quickly find all keyed elements in the original DOM tree.\n    var fromNodesLookup = {};\n    var keyedRemovalList;\n\n    function addKeyedRemoval(key) {\n        if (keyedRemovalList) {\n            keyedRemovalList.push(key);\n        } else {\n            keyedRemovalList = [key];\n        }\n    }\n\n    function walkDiscardedChildNodes(node, skipKeyedNodes) {\n        if (node.nodeType === ELEMENT_NODE) {\n            var curChild = node.firstChild;\n            while (curChild) {\n\n                var key = undefined;\n\n                if (skipKeyedNodes && (key = getNodeKey(curChild))) {\n                    // If we are skipping keyed nodes then we add the key\n                    // to a list so that it can be handled at the very end.\n                    addKeyedRemoval(key);\n                } else {\n                    // Only report the node as discarded if it is not keyed. We do this because\n                    // at the end we loop through all keyed elements that were unmatched\n                    // and then discard them in one final pass.\n                    onNodeDiscarded(curChild);\n                    if (curChild.firstChild) {\n                        walkDiscardedChildNodes(curChild, skipKeyedNodes);\n                    }\n                }\n\n                curChild = curChild.nextSibling;\n            }\n        }\n    }\n\n    /**\n     * Removes a DOM node out of the original DOM\n     *\n     * @param  {Node} node The node to remove\n     * @param  {Node} parentNode The nodes parent\n     * @param  {Boolean} skipKeyedNodes If true then elements with keys will be skipped and not discarded.\n     * @return {undefined}\n     */\n    function removeNode(node, parentNode, skipKeyedNodes) {\n        if (onBeforeNodeDiscarded(node) === false) {\n            return;\n        }\n\n        if (parentNode) {\n            parentNode.removeChild(node);\n        }\n\n        onNodeDiscarded(node);\n        walkDiscardedChildNodes(node, skipKeyedNodes);\n    }\n\n    // // TreeWalker implementation is no faster, but keeping this around in case this changes in the future\n    // function indexTree(root) {\n    //     var treeWalker = document.createTreeWalker(\n    //         root,\n    //         NodeFilter.SHOW_ELEMENT);\n    //\n    //     var el;\n    //     while((el = treeWalker.nextNode())) {\n    //         var key = getNodeKey(el);\n    //         if (key) {\n    //             fromNodesLookup[key] = el;\n    //         }\n    //     }\n    // }\n\n    // // NodeIterator implementation is no faster, but keeping this around in case this changes in the future\n    //\n    // function indexTree(node) {\n    //     var nodeIterator = document.createNodeIterator(node, NodeFilter.SHOW_ELEMENT);\n    //     var el;\n    //     while((el = nodeIterator.nextNode())) {\n    //         var key = getNodeKey(el);\n    //         if (key) {\n    //             fromNodesLookup[key] = el;\n    //         }\n    //     }\n    // }\n\n    function indexTree(node) {\n        if (node.nodeType === ELEMENT_NODE) {\n            var curChild = node.firstChild;\n            while (curChild) {\n                var key = getNodeKey(curChild);\n                if (key) {\n                    fromNodesLookup[key] = curChild;\n                }\n\n                // Walk recursively\n                indexTree(curChild);\n\n                curChild = curChild.nextSibling;\n            }\n        }\n    }\n\n    indexTree(fromNode);\n\n    function handleNodeAdded(el) {\n        onNodeAdded(el);\n\n        var curChild = el.firstChild;\n        while (curChild) {\n            var nextSibling = curChild.nextSibling;\n\n            var key = getNodeKey(curChild);\n            if (key) {\n                var unmatchedFromEl = fromNodesLookup[key];\n                if (unmatchedFromEl && compareNodeNames(curChild, unmatchedFromEl)) {\n                    curChild.parentNode.replaceChild(unmatchedFromEl, curChild);\n                    morphEl(unmatchedFromEl, curChild);\n                }\n            }\n\n            handleNodeAdded(curChild);\n            curChild = nextSibling;\n        }\n    }\n\n    function morphEl(fromEl, toEl, childrenOnly) {\n        var toElKey = getNodeKey(toEl);\n        var curFromNodeKey;\n\n        if (toElKey) {\n            // If an element with an ID is being morphed then it is will be in the final\n            // DOM so clear it out of the saved elements collection\n            delete fromNodesLookup[toElKey];\n        }\n\n        if (toNode.isSameNode && toNode.isSameNode(fromNode)) {\n            return;\n        }\n\n        if (!childrenOnly) {\n            if (onBeforeElUpdated(fromEl, toEl) === false) {\n                return;\n            }\n\n            morphAttrs(fromEl, toEl);\n            onElUpdated(fromEl);\n\n            if (onBeforeElChildrenUpdated(fromEl, toEl) === false) {\n                return;\n            }\n        }\n\n        if (fromEl.nodeName !== 'TEXTAREA') {\n            var curToNodeChild = toEl.firstChild;\n            var curFromNodeChild = fromEl.firstChild;\n            var curToNodeKey;\n\n            var fromNextSibling;\n            var toNextSibling;\n            var matchingFromEl;\n\n            outer: while (curToNodeChild) {\n                toNextSibling = curToNodeChild.nextSibling;\n                curToNodeKey = getNodeKey(curToNodeChild);\n\n                while (curFromNodeChild) {\n                    if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {\n                        return;\n                    }\n\n                    curFromNodeKey = getNodeKey(curFromNodeChild);\n                    fromNextSibling = curFromNodeChild.nextSibling;\n\n                    var curFromNodeType = curFromNodeChild.nodeType;\n\n                    var isCompatible = undefined;\n\n                    if (curFromNodeType === curToNodeChild.nodeType) {\n                        if (curFromNodeType === ELEMENT_NODE) {\n                            // Both nodes being compared are Element nodes\n\n                            if (curToNodeKey) {\n                                // The target node has a key so we want to match it up with the correct element\n                                // in the original DOM tree\n                                if (curToNodeKey !== curFromNodeKey) {\n                                    // The current element in the original DOM tree does not have a matching key so\n                                    // let's check our lookup to see if there is a matching element in the original\n                                    // DOM tree\n                                    if ((matchingFromEl = fromNodesLookup[curToNodeKey])) {\n                                        if (curFromNodeChild.nextSibling === matchingFromEl) {\n                                            // Special case for single element removals. To avoid removing the original\n                                            // DOM node out of the tree (since that can break CSS transitions, etc.),\n                                            // we will instead discard the current node and wait until the next\n                                            // iteration to properly match up the keyed target element with its matching\n                                            // element in the original tree\n                                            isCompatible = false;\n                                        } else {\n                                            // We found a matching keyed element somewhere in the original DOM tree.\n                                            // Let's moving the original DOM node into the current position and morph\n                                            // it.\n\n                                            // NOTE: We use insertBefore instead of replaceChild because we want to go through\n                                            // the `removeNode()` function for the node that is being discarded so that\n                                            // all lifecycle hooks are correctly invoked\n                                            fromEl.insertBefore(matchingFromEl, curFromNodeChild);\n\n                                            if (curFromNodeKey) {\n                                                // Since the node is keyed it might be matched up later so we defer\n                                                // the actual removal to later\n                                                addKeyedRemoval(curFromNodeKey);\n                                            } else {\n                                                // NOTE: we skip nested keyed nodes from being removed since there is\n                                                //       still a chance they will be matched up later\n                                                removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n\n                                            }\n                                            fromNextSibling = curFromNodeChild.nextSibling;\n                                            curFromNodeChild = matchingFromEl;\n                                        }\n                                    } else {\n                                        // The nodes are not compatible since the \"to\" node has a key and there\n                                        // is no matching keyed node in the source tree\n                                        isCompatible = false;\n                                    }\n                                }\n                            } else if (curFromNodeKey) {\n                                // The original has a key\n                                isCompatible = false;\n                            }\n\n                            isCompatible = isCompatible !== false && compareNodeNames(curFromNodeChild, curToNodeChild);\n                            if (isCompatible) {\n                                // We found compatible DOM elements so transform\n                                // the current \"from\" node to match the current\n                                // target DOM node.\n                                morphEl(curFromNodeChild, curToNodeChild);\n                            }\n\n                        } else if (curFromNodeType === TEXT_NODE || curFromNodeType == COMMENT_NODE) {\n                            // Both nodes being compared are Text or Comment nodes\n                            isCompatible = true;\n                            // Simply update nodeValue on the original node to\n                            // change the text value\n                            curFromNodeChild.nodeValue = curToNodeChild.nodeValue;\n                        }\n                    }\n\n                    if (isCompatible) {\n                        // Advance both the \"to\" child and the \"from\" child since we found a match\n                        curToNodeChild = toNextSibling;\n                        curFromNodeChild = fromNextSibling;\n                        continue outer;\n                    }\n\n                    // No compatible match so remove the old node from the DOM and continue trying to find a\n                    // match in the original DOM. However, we only do this if the from node is not keyed\n                    // since it is possible that a keyed node might match up with a node somewhere else in the\n                    // target tree and we don't want to discard it just yet since it still might find a\n                    // home in the final DOM tree. After everything is done we will remove any keyed nodes\n                    // that didn't find a home\n                    if (curFromNodeKey) {\n                        // Since the node is keyed it might be matched up later so we defer\n                        // the actual removal to later\n                        addKeyedRemoval(curFromNodeKey);\n                    } else {\n                        // NOTE: we skip nested keyed nodes from being removed since there is\n                        //       still a chance they will be matched up later\n                        removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n                    }\n\n                    curFromNodeChild = fromNextSibling;\n                }\n\n                // If we got this far then we did not find a candidate match for\n                // our \"to node\" and we exhausted all of the children \"from\"\n                // nodes. Therefore, we will just append the current \"to\" node\n                // to the end\n                if (curToNodeKey && (matchingFromEl = fromNodesLookup[curToNodeKey]) && compareNodeNames(matchingFromEl, curToNodeChild)) {\n                    fromEl.appendChild(matchingFromEl);\n                    morphEl(matchingFromEl, curToNodeChild);\n                } else {\n                    var onBeforeNodeAddedResult = onBeforeNodeAdded(curToNodeChild);\n                    if (onBeforeNodeAddedResult !== false) {\n                        if (onBeforeNodeAddedResult) {\n                            curToNodeChild = onBeforeNodeAddedResult;\n                        }\n\n                        if (curToNodeChild.actualize) {\n                            curToNodeChild = curToNodeChild.actualize(fromEl.ownerDocument || doc);\n                        }\n                        fromEl.appendChild(curToNodeChild);\n                        handleNodeAdded(curToNodeChild);\n                    }\n                }\n\n                curToNodeChild = toNextSibling;\n                curFromNodeChild = fromNextSibling;\n            }\n\n            // We have processed all of the \"to nodes\". If curFromNodeChild is\n            // non-null then we still have some from nodes left over that need\n            // to be removed\n            while (curFromNodeChild) {\n                fromNextSibling = curFromNodeChild.nextSibling;\n                if ((curFromNodeKey = getNodeKey(curFromNodeChild))) {\n                    // Since the node is keyed it might be matched up later so we defer\n                    // the actual removal to later\n                    addKeyedRemoval(curFromNodeKey);\n                } else {\n                    // NOTE: we skip nested keyed nodes from being removed since there is\n                    //       still a chance they will be matched up later\n                    removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n                }\n                curFromNodeChild = fromNextSibling;\n            }\n        }\n\n        var specialElHandler = specialElHandlers[fromEl.nodeName];\n        if (specialElHandler) {\n            specialElHandler(fromEl, toEl);\n        }\n    } // END: morphEl(...)\n\n    var morphedNode = fromNode;\n    var morphedNodeType = morphedNode.nodeType;\n    var toNodeType = toNode.nodeType;\n\n    if (!childrenOnly) {\n        // Handle the case where we are given two DOM nodes that are not\n        // compatible (e.g. <div> --> <span> or <div> --> TEXT)\n        if (morphedNodeType === ELEMENT_NODE) {\n            if (toNodeType === ELEMENT_NODE) {\n                if (!compareNodeNames(fromNode, toNode)) {\n                    onNodeDiscarded(fromNode);\n                    morphedNode = moveChildren(fromNode, createElementNS(toNode.nodeName, toNode.namespaceURI));\n                }\n            } else {\n                // Going from an element node to a text node\n                morphedNode = toNode;\n            }\n        } else if (morphedNodeType === TEXT_NODE || morphedNodeType === COMMENT_NODE) { // Text or comment node\n            if (toNodeType === morphedNodeType) {\n                morphedNode.nodeValue = toNode.nodeValue;\n                return morphedNode;\n            } else {\n                // Text node to something else\n                morphedNode = toNode;\n            }\n        }\n    }\n\n    if (morphedNode === toNode) {\n        // The \"to node\" was not compatible with the \"from node\" so we had to\n        // toss out the \"from node\" and use the \"to node\"\n        onNodeDiscarded(fromNode);\n    } else {\n        morphEl(morphedNode, toNode, childrenOnly);\n\n        // We now need to loop over any keyed nodes that might need to be\n        // removed. We only do the removal if we know that the keyed node\n        // never found a match. When a keyed node is matched up we remove\n        // it out of fromNodesLookup and we use fromNodesLookup to determine\n        // if a keyed node has been matched up or not\n        if (keyedRemovalList) {\n            for (var i=0, len=keyedRemovalList.length; i<len; i++) {\n                var elToRemove = fromNodesLookup[keyedRemovalList[i]];\n                if (elToRemove) {\n                    removeNode(elToRemove, elToRemove.parentNode, false);\n                }\n            }\n        }\n    }\n\n    if (!childrenOnly && morphedNode !== fromNode && fromNode.parentNode) {\n        if (morphedNode.actualize) {\n            morphedNode = morphedNode.actualize(fromNode.ownerDocument || doc);\n        }\n        // If we had to swap out the from node with a new node because the old\n        // node was not compatible with the target node then we need to\n        // replace the old DOM node in the original DOM tree. This is only\n        // possible if the original DOM node was part of a DOM tree which\n        // we know is the case if it has a parent node.\n        fromNode.parentNode.replaceChild(morphedNode, fromNode);\n    }\n\n    return morphedNode;\n}\n\nmodule.exports = morphdom;\n","module.exports = [\n  // attribute events (can be set with attributes)\n  'onclick',\n  'ondblclick',\n  'onmousedown',\n  'onmouseup',\n  'onmouseover',\n  'onmousemove',\n  'onmouseout',\n  'ondragstart',\n  'ondrag',\n  'ondragenter',\n  'ondragleave',\n  'ondragover',\n  'ondrop',\n  'ondragend',\n  'onkeydown',\n  'onkeypress',\n  'onkeyup',\n  'onunload',\n  'onabort',\n  'onerror',\n  'onresize',\n  'onscroll',\n  'onselect',\n  'onchange',\n  'onsubmit',\n  'onreset',\n  'onfocus',\n  'onblur',\n  'oninput',\n  // other common events\n  'oncontextmenu',\n  'onfocusin',\n  'onfocusout'\n]\n","var bel = require('bel') // turns template tag into DOM elements\nvar morphdom = require('morphdom') // efficiently diffs + morphs two DOM elements\nvar defaultEvents = require('./update-events.js') // default events to be copied when dom elements update\n\nmodule.exports = bel\n\n// TODO move this + defaultEvents to a new module once we receive more feedback\nmodule.exports.update = function (fromNode, toNode, opts) {\n  if (!opts) opts = {}\n  if (opts.events !== false) {\n    if (!opts.onBeforeElUpdated) opts.onBeforeElUpdated = copier\n  }\n\n  return morphdom(fromNode, toNode, opts)\n\n  // morphdom only copies attributes. we decided we also wanted to copy events\n  // that can be set via attributes\n  function copier (f, t) {\n    // copy events:\n    var events = opts.events || defaultEvents\n    for (var i = 0; i < events.length; i++) {\n      var ev = events[i]\n      if (t[ev]) { // if new element has a whitelisted attribute\n        f[ev] = t[ev] // update existing element\n      } else if (f[ev]) { // if existing element has it and new one doesnt\n        f[ev] = undefined // remove it from existing element\n      }\n    }\n    // copy values for form elements\n    if ((f.nodeName === 'INPUT' && f.type !== 'file') || f.nodeName === 'TEXTAREA' || f.nodeName === 'SELECT') {\n      if (t.getAttribute('value') === null) t.value = f.value\n    }\n  }\n}\n"]} | |
| var html = require('yo-yo') | |
| var node = render() | |
| document.body.appendChild(node) | |
| function render (content) { | |
| return html` | |
| <div> | |
| <textarea | |
| placeholder="type here!" | |
| ></textarea> | |
| <button | |
| onclick=${update} | |
| >click me!</button> | |
| </div> | |
| ` | |
| } | |
| function update () { | |
| html.update(node, render()) | |
| } | |
| ;}, 0) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "name": "requirebin-sketch", | |
| "version": "1.0.0", | |
| "dependencies": { | |
| "yo-yo": "1.3.0" | |
| } | |
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <body> --> |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <head> --> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment