made with requirebin
Created
August 10, 2017 23:22
-
-
Save ungoldman/f53426fac4f351cc4125cd9a11b6f248 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains 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('choo/html') | |
| var choo = require('choo') | |
| var app = choo() | |
| app.use(titleStore) | |
| app.route('/', mainView) | |
| app.mount('body') | |
| function mainView (state, emit) { | |
| return html` | |
| <div> | |
| <h1>Title: ${state.title}</h1> | |
| <input type="text" value="${state.title}" oninput=${update} /> | |
| </div> | |
| ` | |
| function update (e) { | |
| emit('update', e.target.value) | |
| } | |
| } | |
| function titleStore (state, emitter) { | |
| state.title = 'Not quite set yet' | |
| emitter.on('DOMContentLoaded', function () { | |
| emitter.on('update', function (newTitle) { | |
| state.title = newTitle | |
| emitter.emit('render') | |
| }) | |
| }) | |
| } |
This file contains 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){ | |
| (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 : {}) | |
| },{"min-document":1}],3:[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 : {}) | |
| },{}],4:[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 | |
| } | |
| } | |
| var oldValue = f.value | |
| var newValue = t.value | |
| // copy values for form elements | |
| if ((f.nodeName === 'INPUT' && f.type !== 'file') || f.nodeName === 'SELECT') { | |
| if (!newValue) { | |
| t.value = f.value | |
| } else if (newValue !== oldValue) { | |
| f.value = newValue | |
| } | |
| } else if (f.nodeName === 'TEXTAREA') { | |
| if (t.getAttribute('value') === null) f.value = t.value | |
| } | |
| } | |
| } | |
| },{"./update-events.js":10,"bel":5,"morphdom":9}],5:[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 XLINKNS = 'http://www.w3.org/1999/xlink' | |
| 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 belOnload () { | |
| load(el) | |
| }, function belOnunload () { | |
| 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) { | |
| if (p === 'xlink:href') { | |
| el.setAttributeNS(XLINKNS, p, val) | |
| } else if (/^xmlns($|:)/i.test(p)) { | |
| // skip xmlns definitions | |
| } else { | |
| 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.default = module.exports | |
| module.exports.createElement = belCreateElement | |
| },{"global/document":2,"hyperx":6,"on-load":8}],6:[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', '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":7}],7:[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) | |
| } | |
| } | |
| },{}],8:[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":2,"global/window":3}],9:[function(require,module,exports){ | |
| 'use strict'; | |
| var range; // Create a range object for efficently rendering strings to elements. | |
| var NS_XHTML = 'http://www.w3.org/1999/xhtml'; | |
| var doc = typeof document === 'undefined' ? undefined : document; | |
| var testEl = doc ? | |
| doc.body || doc.createElement('div') : | |
| {}; | |
| // Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32> | |
| // (IE7+ support) <=IE7 does not support el.hasAttribute(name) | |
| var actualHasAttributeNS; | |
| if (testEl.hasAttributeNS) { | |
| actualHasAttributeNS = function(el, namespaceURI, name) { | |
| return el.hasAttributeNS(namespaceURI, name); | |
| }; | |
| } else if (testEl.hasAttribute) { | |
| actualHasAttributeNS = function(el, namespaceURI, name) { | |
| return el.hasAttribute(name); | |
| }; | |
| } else { | |
| actualHasAttributeNS = function(el, namespaceURI, name) { | |
| return el.getAttributeNode(namespaceURI, name) != null; | |
| }; | |
| } | |
| var hasAttributeNS = actualHasAttributeNS; | |
| 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]; | |
| } | |
| /** | |
| * 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); | |
| } | |
| /** | |
| * 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 morphAttrs(fromNode, toNode) { | |
| var attrs = toNode.attributes; | |
| var i; | |
| var attr; | |
| var attrName; | |
| var attrNamespaceURI; | |
| var attrValue; | |
| var fromValue; | |
| 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); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| 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) { | |
| // Needed for IE. Apparently IE sets the placeholder as the | |
| // node value and vise versa. This ignores an empty update. | |
| if (newValue === '' && fromEl.firstChild.nodeValue === fromEl.placeholder) { | |
| return; | |
| } | |
| fromEl.firstChild.nodeValue = newValue; | |
| } | |
| }, | |
| SELECT: function(fromEl, toEl) { | |
| if (!hasAttributeNS(toEl, null, 'multiple')) { | |
| var selectedIndex = -1; | |
| var i = 0; | |
| var curChild = toEl.firstChild; | |
| while(curChild) { | |
| var nodeName = curChild.nodeName; | |
| if (nodeName && nodeName.toUpperCase() === 'OPTION') { | |
| if (hasAttributeNS(curChild, null, 'selected')) { | |
| selectedIndex = i; | |
| break; | |
| } | |
| i++; | |
| } | |
| curChild = curChild.nextSibling; | |
| } | |
| fromEl.selectedIndex = i; | |
| } | |
| } | |
| }; | |
| var ELEMENT_NODE = 1; | |
| var TEXT_NODE = 3; | |
| var COMMENT_NODE = 8; | |
| function noop() {} | |
| function defaultGetNodeKey(node) { | |
| return node.id; | |
| } | |
| function morphdomFactory(morphAttrs) { | |
| return 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) { | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) { | |
| curToNodeChild = toNextSibling; | |
| curFromNodeChild = fromNextSibling; | |
| continue outer; | |
| } | |
| curFromNodeKey = getNodeKey(curFromNodeChild); | |
| 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); | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| 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 = 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; | |
| }; | |
| } | |
| var morphdom = morphdomFactory(morphAttrs); | |
| module.exports = morphdom; | |
| },{}],10:[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' | |
| ] | |
| },{}],"choo/html":[function(require,module,exports){ | |
| module.exports = require('yo-yo') | |
| },{"yo-yo":4}]},{},[]) | |
| //# sourceMappingURL=data:application/json;charset=utf-8;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/global/document.js","node_modules/global/window.js","node_modules/yo-yo/index.js","node_modules/yo-yo/node_modules/bel/index.js","node_modules/yo-yo/node_modules/bel/node_modules/hyperx/index.js","node_modules/yo-yo/node_modules/bel/node_modules/hyperx/node_modules/hyperscript-attribute-to-property/index.js","node_modules/yo-yo/node_modules/bel/node_modules/on-load/index.js","node_modules/yo-yo/node_modules/morphdom/dist/morphdom.js","node_modules/yo-yo/update-events.js","choo/html"],"names":[],"mappings":"AAAA;ACAA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjqBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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","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})","","var 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","if (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","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    var oldValue = f.value\n    var newValue = t.value\n    // copy values for form elements\n    if ((f.nodeName === 'INPUT' && f.type !== 'file') || f.nodeName === 'SELECT') {\n      if (!newValue) {\n        t.value = f.value\n      } else if (newValue !== oldValue) {\n        f.value = newValue\n      }\n    } else if (f.nodeName === 'TEXTAREA') {\n      if (t.getAttribute('value') === null) f.value = t.value\n    }\n  }\n}\n","var document = require('global/document')\nvar hyperx = require('hyperx')\nvar onload = require('on-load')\n\nvar SVGNS = 'http://www.w3.org/2000/svg'\nvar XLINKNS = 'http://www.w3.org/1999/xlink'\n\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 belOnload () {\n      load(el)\n    }, function belOnunload () {\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          if (p === 'xlink:href') {\n            el.setAttributeNS(XLINKNS, p, val)\n          } else if (/^xmlns($|:)/i.test(p)) {\n            // skip xmlns definitions\n          } else {\n            el.setAttributeNS(null, p, val)\n          }\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.default = module.exports\nmodule.exports.createElement = belCreateElement\n","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', '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\nvar range; // Create a range object for efficently rendering strings to elements.\nvar NS_XHTML = 'http://www.w3.org/1999/xhtml';\n\nvar doc = typeof document === 'undefined' ? undefined : document;\n\nvar testEl = doc ?\n    doc.body || doc.createElement('div') :\n    {};\n\n// Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32>\n// (IE7+ support) <=IE7 does not support el.hasAttribute(name)\nvar actualHasAttributeNS;\n\nif (testEl.hasAttributeNS) {\n    actualHasAttributeNS = function(el, namespaceURI, name) {\n        return el.hasAttributeNS(namespaceURI, name);\n    };\n} else if (testEl.hasAttribute) {\n    actualHasAttributeNS = function(el, namespaceURI, name) {\n        return el.hasAttribute(name);\n    };\n} else {\n    actualHasAttributeNS = function(el, namespaceURI, name) {\n        return el.getAttributeNode(namespaceURI, name) != null;\n    };\n}\n\nvar hasAttributeNS = actualHasAttributeNS;\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\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 * 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 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    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    // 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\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            // Needed for IE. Apparently IE sets the placeholder as the\n            // node value and vise versa. This ignores an empty update.\n            if (newValue === '' && fromEl.firstChild.nodeValue === fromEl.placeholder) {\n                return;\n            }\n\n            fromEl.firstChild.nodeValue = newValue;\n        }\n    },\n    SELECT: function(fromEl, toEl) {\n        if (!hasAttributeNS(toEl, null, 'multiple')) {\n            var selectedIndex = -1;\n            var i = 0;\n            var curChild = toEl.firstChild;\n            while(curChild) {\n                var nodeName = curChild.nodeName;\n                if (nodeName && nodeName.toUpperCase() === 'OPTION') {\n                    if (hasAttributeNS(curChild, null, 'selected')) {\n                        selectedIndex = i;\n                        break;\n                    }\n                    i++;\n                }\n                curChild = curChild.nextSibling;\n            }\n\n            fromEl.selectedIndex = i;\n        }\n    }\n};\n\nvar ELEMENT_NODE = 1;\nvar TEXT_NODE = 3;\nvar COMMENT_NODE = 8;\n\nfunction noop() {}\n\nfunction defaultGetNodeKey(node) {\n    return node.id;\n}\n\nfunction morphdomFactory(morphAttrs) {\n\n    return function 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                        fromNextSibling = curFromNodeChild.nextSibling;\n\n                        if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {\n                            curToNodeChild = toNextSibling;\n                            curFromNodeChild = fromNextSibling;\n                            continue outer;\n                        }\n\n                        curFromNodeKey = getNodeKey(curFromNodeChild);\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                                                fromNextSibling = curFromNodeChild.nextSibling;\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                                                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}\n\nvar morphdom = morphdomFactory(morphAttrs);\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","module.exports = require('yo-yo')\n"]} | |
| 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){ | |
| // http://wiki.commonjs.org/wiki/Unit_Testing/1.0 | |
| // | |
| // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! | |
| // | |
| // Originally from narwhal.js (http://narwhaljs.org) | |
| // Copyright (c) 2009 Thomas Robinson <280north.com> | |
| // | |
| // Permission is hereby granted, free of charge, to any person obtaining a copy | |
| // of this software and associated documentation files (the 'Software'), to | |
| // deal in the Software without restriction, including without limitation the | |
| // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | |
| // sell copies of the Software, and to permit persons to whom the Software is | |
| // furnished to do so, subject to the following conditions: | |
| // | |
| // The above copyright notice and this permission notice shall be included in | |
| // all copies or substantial portions of the Software. | |
| // | |
| // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
| // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
| // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
| // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| // when used in node, this will actually load the util module we depend on | |
| // versus loading the builtin util module as happens otherwise | |
| // this is a bug in node module loading as far as I am concerned | |
| var util = require('util/'); | |
| var pSlice = Array.prototype.slice; | |
| var hasOwn = Object.prototype.hasOwnProperty; | |
| // 1. The assert module provides functions that throw | |
| // AssertionError's when particular conditions are not met. The | |
| // assert module must conform to the following interface. | |
| var assert = module.exports = ok; | |
| // 2. The AssertionError is defined in assert. | |
| // new assert.AssertionError({ message: message, | |
| // actual: actual, | |
| // expected: expected }) | |
| assert.AssertionError = function AssertionError(options) { | |
| this.name = 'AssertionError'; | |
| this.actual = options.actual; | |
| this.expected = options.expected; | |
| this.operator = options.operator; | |
| if (options.message) { | |
| this.message = options.message; | |
| this.generatedMessage = false; | |
| } else { | |
| this.message = getMessage(this); | |
| this.generatedMessage = true; | |
| } | |
| var stackStartFunction = options.stackStartFunction || fail; | |
| if (Error.captureStackTrace) { | |
| Error.captureStackTrace(this, stackStartFunction); | |
| } | |
| else { | |
| // non v8 browsers so we can have a stacktrace | |
| var err = new Error(); | |
| if (err.stack) { | |
| var out = err.stack; | |
| // try to strip useless frames | |
| var fn_name = stackStartFunction.name; | |
| var idx = out.indexOf('\n' + fn_name); | |
| if (idx >= 0) { | |
| // once we have located the function frame | |
| // we need to strip out everything before it (and its line) | |
| var next_line = out.indexOf('\n', idx + 1); | |
| out = out.substring(next_line + 1); | |
| } | |
| this.stack = out; | |
| } | |
| } | |
| }; | |
| // assert.AssertionError instanceof Error | |
| util.inherits(assert.AssertionError, Error); | |
| function replacer(key, value) { | |
| if (util.isUndefined(value)) { | |
| return '' + value; | |
| } | |
| if (util.isNumber(value) && !isFinite(value)) { | |
| return value.toString(); | |
| } | |
| if (util.isFunction(value) || util.isRegExp(value)) { | |
| return value.toString(); | |
| } | |
| return value; | |
| } | |
| function truncate(s, n) { | |
| if (util.isString(s)) { | |
| return s.length < n ? s : s.slice(0, n); | |
| } else { | |
| return s; | |
| } | |
| } | |
| function getMessage(self) { | |
| return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' + | |
| self.operator + ' ' + | |
| truncate(JSON.stringify(self.expected, replacer), 128); | |
| } | |
| // At present only the three keys mentioned above are used and | |
| // understood by the spec. Implementations or sub modules can pass | |
| // other keys to the AssertionError's constructor - they will be | |
| // ignored. | |
| // 3. All of the following functions must throw an AssertionError | |
| // when a corresponding condition is not met, with a message that | |
| // may be undefined if not provided. All assertion methods provide | |
| // both the actual and expected values to the assertion error for | |
| // display purposes. | |
| function fail(actual, expected, message, operator, stackStartFunction) { | |
| throw new assert.AssertionError({ | |
| message: message, | |
| actual: actual, | |
| expected: expected, | |
| operator: operator, | |
| stackStartFunction: stackStartFunction | |
| }); | |
| } | |
| // EXTENSION! allows for well behaved errors defined elsewhere. | |
| assert.fail = fail; | |
| // 4. Pure assertion tests whether a value is truthy, as determined | |
| // by !!guard. | |
| // assert.ok(guard, message_opt); | |
| // This statement is equivalent to assert.equal(true, !!guard, | |
| // message_opt);. To test strictly for the value true, use | |
| // assert.strictEqual(true, guard, message_opt);. | |
| function ok(value, message) { | |
| if (!value) fail(value, true, message, '==', assert.ok); | |
| } | |
| assert.ok = ok; | |
| // 5. The equality assertion tests shallow, coercive equality with | |
| // ==. | |
| // assert.equal(actual, expected, message_opt); | |
| assert.equal = function equal(actual, expected, message) { | |
| if (actual != expected) fail(actual, expected, message, '==', assert.equal); | |
| }; | |
| // 6. The non-equality assertion tests for whether two objects are not equal | |
| // with != assert.notEqual(actual, expected, message_opt); | |
| assert.notEqual = function notEqual(actual, expected, message) { | |
| if (actual == expected) { | |
| fail(actual, expected, message, '!=', assert.notEqual); | |
| } | |
| }; | |
| // 7. The equivalence assertion tests a deep equality relation. | |
| // assert.deepEqual(actual, expected, message_opt); | |
| assert.deepEqual = function deepEqual(actual, expected, message) { | |
| if (!_deepEqual(actual, expected)) { | |
| fail(actual, expected, message, 'deepEqual', assert.deepEqual); | |
| } | |
| }; | |
| function _deepEqual(actual, expected) { | |
| // 7.1. All identical values are equivalent, as determined by ===. | |
| if (actual === expected) { | |
| return true; | |
| } else if (util.isBuffer(actual) && util.isBuffer(expected)) { | |
| if (actual.length != expected.length) return false; | |
| for (var i = 0; i < actual.length; i++) { | |
| if (actual[i] !== expected[i]) return false; | |
| } | |
| return true; | |
| // 7.2. If the expected value is a Date object, the actual value is | |
| // equivalent if it is also a Date object that refers to the same time. | |
| } else if (util.isDate(actual) && util.isDate(expected)) { | |
| return actual.getTime() === expected.getTime(); | |
| // 7.3 If the expected value is a RegExp object, the actual value is | |
| // equivalent if it is also a RegExp object with the same source and | |
| // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). | |
| } else if (util.isRegExp(actual) && util.isRegExp(expected)) { | |
| return actual.source === expected.source && | |
| actual.global === expected.global && | |
| actual.multiline === expected.multiline && | |
| actual.lastIndex === expected.lastIndex && | |
| actual.ignoreCase === expected.ignoreCase; | |
| // 7.4. Other pairs that do not both pass typeof value == 'object', | |
| // equivalence is determined by ==. | |
| } else if (!util.isObject(actual) && !util.isObject(expected)) { | |
| return actual == expected; | |
| // 7.5 For all other Object pairs, including Array objects, equivalence is | |
| // determined by having the same number of owned properties (as verified | |
| // with Object.prototype.hasOwnProperty.call), the same set of keys | |
| // (although not necessarily the same order), equivalent values for every | |
| // corresponding key, and an identical 'prototype' property. Note: this | |
| // accounts for both named and indexed properties on Arrays. | |
| } else { | |
| return objEquiv(actual, expected); | |
| } | |
| } | |
| function isArguments(object) { | |
| return Object.prototype.toString.call(object) == '[object Arguments]'; | |
| } | |
| function objEquiv(a, b) { | |
| if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) | |
| return false; | |
| // an identical 'prototype' property. | |
| if (a.prototype !== b.prototype) return false; | |
| // if one is a primitive, the other must be same | |
| if (util.isPrimitive(a) || util.isPrimitive(b)) { | |
| return a === b; | |
| } | |
| var aIsArgs = isArguments(a), | |
| bIsArgs = isArguments(b); | |
| if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) | |
| return false; | |
| if (aIsArgs) { | |
| a = pSlice.call(a); | |
| b = pSlice.call(b); | |
| return _deepEqual(a, b); | |
| } | |
| var ka = objectKeys(a), | |
| kb = objectKeys(b), | |
| key, i; | |
| // having the same number of owned properties (keys incorporates | |
| // hasOwnProperty) | |
| if (ka.length != kb.length) | |
| return false; | |
| //the same set of keys (although not necessarily the same order), | |
| ka.sort(); | |
| kb.sort(); | |
| //~~~cheap key test | |
| for (i = ka.length - 1; i >= 0; i--) { | |
| if (ka[i] != kb[i]) | |
| return false; | |
| } | |
| //equivalent values for every corresponding key, and | |
| //~~~possibly expensive deep test | |
| for (i = ka.length - 1; i >= 0; i--) { | |
| key = ka[i]; | |
| if (!_deepEqual(a[key], b[key])) return false; | |
| } | |
| return true; | |
| } | |
| // 8. The non-equivalence assertion tests for any deep inequality. | |
| // assert.notDeepEqual(actual, expected, message_opt); | |
| assert.notDeepEqual = function notDeepEqual(actual, expected, message) { | |
| if (_deepEqual(actual, expected)) { | |
| fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); | |
| } | |
| }; | |
| // 9. The strict equality assertion tests strict equality, as determined by ===. | |
| // assert.strictEqual(actual, expected, message_opt); | |
| assert.strictEqual = function strictEqual(actual, expected, message) { | |
| if (actual !== expected) { | |
| fail(actual, expected, message, '===', assert.strictEqual); | |
| } | |
| }; | |
| // 10. The strict non-equality assertion tests for strict inequality, as | |
| // determined by !==. assert.notStrictEqual(actual, expected, message_opt); | |
| assert.notStrictEqual = function notStrictEqual(actual, expected, message) { | |
| if (actual === expected) { | |
| fail(actual, expected, message, '!==', assert.notStrictEqual); | |
| } | |
| }; | |
| function expectedException(actual, expected) { | |
| if (!actual || !expected) { | |
| return false; | |
| } | |
| if (Object.prototype.toString.call(expected) == '[object RegExp]') { | |
| return expected.test(actual); | |
| } else if (actual instanceof expected) { | |
| return true; | |
| } else if (expected.call({}, actual) === true) { | |
| return true; | |
| } | |
| return false; | |
| } | |
| function _throws(shouldThrow, block, expected, message) { | |
| var actual; | |
| if (util.isString(expected)) { | |
| message = expected; | |
| expected = null; | |
| } | |
| try { | |
| block(); | |
| } catch (e) { | |
| actual = e; | |
| } | |
| message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + | |
| (message ? ' ' + message : '.'); | |
| if (shouldThrow && !actual) { | |
| fail(actual, expected, 'Missing expected exception' + message); | |
| } | |
| if (!shouldThrow && expectedException(actual, expected)) { | |
| fail(actual, expected, 'Got unwanted exception' + message); | |
| } | |
| if ((shouldThrow && actual && expected && | |
| !expectedException(actual, expected)) || (!shouldThrow && actual)) { | |
| throw actual; | |
| } | |
| } | |
| // 11. Expected to throw an error: | |
| // assert.throws(block, Error_opt, message_opt); | |
| assert.throws = function(block, /*optional*/error, /*optional*/message) { | |
| _throws.apply(this, [true].concat(pSlice.call(arguments))); | |
| }; | |
| // EXTENSION! This is annoying to write outside this module. | |
| assert.doesNotThrow = function(block, /*optional*/message) { | |
| _throws.apply(this, [false].concat(pSlice.call(arguments))); | |
| }; | |
| assert.ifError = function(err) { if (err) {throw err;}}; | |
| var objectKeys = Object.keys || function (obj) { | |
| var keys = []; | |
| for (var key in obj) { | |
| if (hasOwn.call(obj, key)) keys.push(key); | |
| } | |
| return keys; | |
| }; | |
| },{"util/":6}],2:[function(require,module,exports){ | |
| },{}],3:[function(require,module,exports){ | |
| // shim for using process in browser | |
| var process = module.exports = {}; | |
| // cached from whatever global is present so that test runners that stub it | |
| // don't break things. But we need to wrap it in a try catch in case it is | |
| // wrapped in strict mode code which doesn't define any globals. It's inside a | |
| // function because try/catches deoptimize in certain engines. | |
| var cachedSetTimeout; | |
| var cachedClearTimeout; | |
| function defaultSetTimout() { | |
| throw new Error('setTimeout has not been defined'); | |
| } | |
| function defaultClearTimeout () { | |
| throw new Error('clearTimeout has not been defined'); | |
| } | |
| (function () { | |
| try { | |
| if (typeof setTimeout === 'function') { | |
| cachedSetTimeout = setTimeout; | |
| } else { | |
| cachedSetTimeout = defaultSetTimout; | |
| } | |
| } catch (e) { | |
| cachedSetTimeout = defaultSetTimout; | |
| } | |
| try { | |
| if (typeof clearTimeout === 'function') { | |
| cachedClearTimeout = clearTimeout; | |
| } else { | |
| cachedClearTimeout = defaultClearTimeout; | |
| } | |
| } catch (e) { | |
| cachedClearTimeout = defaultClearTimeout; | |
| } | |
| } ()) | |
| function runTimeout(fun) { | |
| if (cachedSetTimeout === setTimeout) { | |
| //normal enviroments in sane situations | |
| return setTimeout(fun, 0); | |
| } | |
| // if setTimeout wasn't available but was latter defined | |
| if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { | |
| cachedSetTimeout = setTimeout; | |
| return setTimeout(fun, 0); | |
| } | |
| try { | |
| // when when somebody has screwed with setTimeout but no I.E. maddness | |
| return cachedSetTimeout(fun, 0); | |
| } catch(e){ | |
| try { | |
| // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | |
| return cachedSetTimeout.call(null, fun, 0); | |
| } catch(e){ | |
| // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error | |
| return cachedSetTimeout.call(this, fun, 0); | |
| } | |
| } | |
| } | |
| function runClearTimeout(marker) { | |
| if (cachedClearTimeout === clearTimeout) { | |
| //normal enviroments in sane situations | |
| return clearTimeout(marker); | |
| } | |
| // if clearTimeout wasn't available but was latter defined | |
| if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { | |
| cachedClearTimeout = clearTimeout; | |
| return clearTimeout(marker); | |
| } | |
| try { | |
| // when when somebody has screwed with setTimeout but no I.E. maddness | |
| return cachedClearTimeout(marker); | |
| } catch (e){ | |
| try { | |
| // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally | |
| return cachedClearTimeout.call(null, marker); | |
| } catch (e){ | |
| // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. | |
| // Some versions of I.E. have different rules for clearTimeout vs setTimeout | |
| return cachedClearTimeout.call(this, marker); | |
| } | |
| } | |
| } | |
| var queue = []; | |
| var draining = false; | |
| var currentQueue; | |
| var queueIndex = -1; | |
| function cleanUpNextTick() { | |
| if (!draining || !currentQueue) { | |
| return; | |
| } | |
| draining = false; | |
| if (currentQueue.length) { | |
| queue = currentQueue.concat(queue); | |
| } else { | |
| queueIndex = -1; | |
| } | |
| if (queue.length) { | |
| drainQueue(); | |
| } | |
| } | |
| function drainQueue() { | |
| if (draining) { | |
| return; | |
| } | |
| var timeout = runTimeout(cleanUpNextTick); | |
| draining = true; | |
| var len = queue.length; | |
| while(len) { | |
| currentQueue = queue; | |
| queue = []; | |
| while (++queueIndex < len) { | |
| if (currentQueue) { | |
| currentQueue[queueIndex].run(); | |
| } | |
| } | |
| queueIndex = -1; | |
| len = queue.length; | |
| } | |
| currentQueue = null; | |
| draining = false; | |
| runClearTimeout(timeout); | |
| } | |
| process.nextTick = function (fun) { | |
| var args = new Array(arguments.length - 1); | |
| if (arguments.length > 1) { | |
| for (var i = 1; i < arguments.length; i++) { | |
| args[i - 1] = arguments[i]; | |
| } | |
| } | |
| queue.push(new Item(fun, args)); | |
| if (queue.length === 1 && !draining) { | |
| runTimeout(drainQueue); | |
| } | |
| }; | |
| // v8 likes predictible objects | |
| function Item(fun, array) { | |
| this.fun = fun; | |
| this.array = array; | |
| } | |
| Item.prototype.run = function () { | |
| this.fun.apply(null, this.array); | |
| }; | |
| process.title = 'browser'; | |
| process.browser = true; | |
| process.env = {}; | |
| process.argv = []; | |
| process.version = ''; // empty string to avoid regexp issues | |
| process.versions = {}; | |
| function noop() {} | |
| process.on = noop; | |
| process.addListener = noop; | |
| process.once = noop; | |
| process.off = noop; | |
| process.removeListener = noop; | |
| process.removeAllListeners = noop; | |
| process.emit = noop; | |
| process.binding = function (name) { | |
| throw new Error('process.binding is not supported'); | |
| }; | |
| process.cwd = function () { return '/' }; | |
| process.chdir = function (dir) { | |
| throw new Error('process.chdir is not supported'); | |
| }; | |
| process.umask = function() { return 0; }; | |
| },{}],4:[function(require,module,exports){ | |
| if (typeof Object.create === 'function') { | |
| // implementation from standard node.js 'util' module | |
| module.exports = function inherits(ctor, superCtor) { | |
| ctor.super_ = superCtor | |
| ctor.prototype = Object.create(superCtor.prototype, { | |
| constructor: { | |
| value: ctor, | |
| enumerable: false, | |
| writable: true, | |
| configurable: true | |
| } | |
| }); | |
| }; | |
| } else { | |
| // old school shim for old browsers | |
| module.exports = function inherits(ctor, superCtor) { | |
| ctor.super_ = superCtor | |
| var TempCtor = function () {} | |
| TempCtor.prototype = superCtor.prototype | |
| ctor.prototype = new TempCtor() | |
| ctor.prototype.constructor = ctor | |
| } | |
| } | |
| },{}],5:[function(require,module,exports){ | |
| module.exports = function isBuffer(arg) { | |
| return arg && typeof arg === 'object' | |
| && typeof arg.copy === 'function' | |
| && typeof arg.fill === 'function' | |
| && typeof arg.readUInt8 === 'function'; | |
| } | |
| },{}],6:[function(require,module,exports){ | |
| (function (process,global){ | |
| // Copyright Joyent, Inc. and other Node contributors. | |
| // | |
| // Permission is hereby granted, free of charge, to any person obtaining a | |
| // copy of this software and associated documentation files (the | |
| // "Software"), to deal in the Software without restriction, including | |
| // without limitation the rights to use, copy, modify, merge, publish, | |
| // distribute, sublicense, and/or sell copies of the Software, and to permit | |
| // persons to whom the Software is furnished to do so, subject to the | |
| // following conditions: | |
| // | |
| // The above copyright notice and this permission notice shall be included | |
| // in all copies or substantial portions of the Software. | |
| // | |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
| // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
| // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN | |
| // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |
| // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
| // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
| // USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| var formatRegExp = /%[sdj%]/g; | |
| exports.format = function(f) { | |
| if (!isString(f)) { | |
| var objects = []; | |
| for (var i = 0; i < arguments.length; i++) { | |
| objects.push(inspect(arguments[i])); | |
| } | |
| return objects.join(' '); | |
| } | |
| var i = 1; | |
| var args = arguments; | |
| var len = args.length; | |
| var str = String(f).replace(formatRegExp, function(x) { | |
| if (x === '%%') return '%'; | |
| if (i >= len) return x; | |
| switch (x) { | |
| case '%s': return String(args[i++]); | |
| case '%d': return Number(args[i++]); | |
| case '%j': | |
| try { | |
| return JSON.stringify(args[i++]); | |
| } catch (_) { | |
| return '[Circular]'; | |
| } | |
| default: | |
| return x; | |
| } | |
| }); | |
| for (var x = args[i]; i < len; x = args[++i]) { | |
| if (isNull(x) || !isObject(x)) { | |
| str += ' ' + x; | |
| } else { | |
| str += ' ' + inspect(x); | |
| } | |
| } | |
| return str; | |
| }; | |
| // Mark that a method should not be used. | |
| // Returns a modified function which warns once by default. | |
| // If --no-deprecation is set, then it is a no-op. | |
| exports.deprecate = function(fn, msg) { | |
| // Allow for deprecating things in the process of starting up. | |
| if (isUndefined(global.process)) { | |
| return function() { | |
| return exports.deprecate(fn, msg).apply(this, arguments); | |
| }; | |
| } | |
| if (process.noDeprecation === true) { | |
| return fn; | |
| } | |
| var warned = false; | |
| function deprecated() { | |
| if (!warned) { | |
| if (process.throwDeprecation) { | |
| throw new Error(msg); | |
| } else if (process.traceDeprecation) { | |
| console.trace(msg); | |
| } else { | |
| console.error(msg); | |
| } | |
| warned = true; | |
| } | |
| return fn.apply(this, arguments); | |
| } | |
| return deprecated; | |
| }; | |
| var debugs = {}; | |
| var debugEnviron; | |
| exports.debuglog = function(set) { | |
| if (isUndefined(debugEnviron)) | |
| debugEnviron = process.env.NODE_DEBUG || ''; | |
| set = set.toUpperCase(); | |
| if (!debugs[set]) { | |
| if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { | |
| var pid = process.pid; | |
| debugs[set] = function() { | |
| var msg = exports.format.apply(exports, arguments); | |
| console.error('%s %d: %s', set, pid, msg); | |
| }; | |
| } else { | |
| debugs[set] = function() {}; | |
| } | |
| } | |
| return debugs[set]; | |
| }; | |
| /** | |
| * Echos the value of a value. Trys to print the value out | |
| * in the best way possible given the different types. | |
| * | |
| * @param {Object} obj The object to print out. | |
| * @param {Object} opts Optional options object that alters the output. | |
| */ | |
| /* legacy: obj, showHidden, depth, colors*/ | |
| function inspect(obj, opts) { | |
| // default options | |
| var ctx = { | |
| seen: [], | |
| stylize: stylizeNoColor | |
| }; | |
| // legacy... | |
| if (arguments.length >= 3) ctx.depth = arguments[2]; | |
| if (arguments.length >= 4) ctx.colors = arguments[3]; | |
| if (isBoolean(opts)) { | |
| // legacy... | |
| ctx.showHidden = opts; | |
| } else if (opts) { | |
| // got an "options" object | |
| exports._extend(ctx, opts); | |
| } | |
| // set default options | |
| if (isUndefined(ctx.showHidden)) ctx.showHidden = false; | |
| if (isUndefined(ctx.depth)) ctx.depth = 2; | |
| if (isUndefined(ctx.colors)) ctx.colors = false; | |
| if (isUndefined(ctx.customInspect)) ctx.customInspect = true; | |
| if (ctx.colors) ctx.stylize = stylizeWithColor; | |
| return formatValue(ctx, obj, ctx.depth); | |
| } | |
| exports.inspect = inspect; | |
| // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics | |
| inspect.colors = { | |
| 'bold' : [1, 22], | |
| 'italic' : [3, 23], | |
| 'underline' : [4, 24], | |
| 'inverse' : [7, 27], | |
| 'white' : [37, 39], | |
| 'grey' : [90, 39], | |
| 'black' : [30, 39], | |
| 'blue' : [34, 39], | |
| 'cyan' : [36, 39], | |
| 'green' : [32, 39], | |
| 'magenta' : [35, 39], | |
| 'red' : [31, 39], | |
| 'yellow' : [33, 39] | |
| }; | |
| // Don't use 'blue' not visible on cmd.exe | |
| inspect.styles = { | |
| 'special': 'cyan', | |
| 'number': 'yellow', | |
| 'boolean': 'yellow', | |
| 'undefined': 'grey', | |
| 'null': 'bold', | |
| 'string': 'green', | |
| 'date': 'magenta', | |
| // "name": intentionally not styling | |
| 'regexp': 'red' | |
| }; | |
| function stylizeWithColor(str, styleType) { | |
| var style = inspect.styles[styleType]; | |
| if (style) { | |
| return '\u001b[' + inspect.colors[style][0] + 'm' + str + | |
| '\u001b[' + inspect.colors[style][1] + 'm'; | |
| } else { | |
| return str; | |
| } | |
| } | |
| function stylizeNoColor(str, styleType) { | |
| return str; | |
| } | |
| function arrayToHash(array) { | |
| var hash = {}; | |
| array.forEach(function(val, idx) { | |
| hash[val] = true; | |
| }); | |
| return hash; | |
| } | |
| function formatValue(ctx, value, recurseTimes) { | |
| // Provide a hook for user-specified inspect functions. | |
| // Check that value is an object with an inspect function on it | |
| if (ctx.customInspect && | |
| value && | |
| isFunction(value.inspect) && | |
| // Filter out the util module, it's inspect function is special | |
| value.inspect !== exports.inspect && | |
| // Also filter out any prototype objects using the circular check. | |
| !(value.constructor && value.constructor.prototype === value)) { | |
| var ret = value.inspect(recurseTimes, ctx); | |
| if (!isString(ret)) { | |
| ret = formatValue(ctx, ret, recurseTimes); | |
| } | |
| return ret; | |
| } | |
| // Primitive types cannot have properties | |
| var primitive = formatPrimitive(ctx, value); | |
| if (primitive) { | |
| return primitive; | |
| } | |
| // Look up the keys of the object. | |
| var keys = Object.keys(value); | |
| var visibleKeys = arrayToHash(keys); | |
| if (ctx.showHidden) { | |
| keys = Object.getOwnPropertyNames(value); | |
| } | |
| // IE doesn't make error fields non-enumerable | |
| // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx | |
| if (isError(value) | |
| && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { | |
| return formatError(value); | |
| } | |
| // Some type of object without properties can be shortcutted. | |
| if (keys.length === 0) { | |
| if (isFunction(value)) { | |
| var name = value.name ? ': ' + value.name : ''; | |
| return ctx.stylize('[Function' + name + ']', 'special'); | |
| } | |
| if (isRegExp(value)) { | |
| return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | |
| } | |
| if (isDate(value)) { | |
| return ctx.stylize(Date.prototype.toString.call(value), 'date'); | |
| } | |
| if (isError(value)) { | |
| return formatError(value); | |
| } | |
| } | |
| var base = '', array = false, braces = ['{', '}']; | |
| // Make Array say that they are Array | |
| if (isArray(value)) { | |
| array = true; | |
| braces = ['[', ']']; | |
| } | |
| // Make functions say that they are functions | |
| if (isFunction(value)) { | |
| var n = value.name ? ': ' + value.name : ''; | |
| base = ' [Function' + n + ']'; | |
| } | |
| // Make RegExps say that they are RegExps | |
| if (isRegExp(value)) { | |
| base = ' ' + RegExp.prototype.toString.call(value); | |
| } | |
| // Make dates with properties first say the date | |
| if (isDate(value)) { | |
| base = ' ' + Date.prototype.toUTCString.call(value); | |
| } | |
| // Make error with message first say the error | |
| if (isError(value)) { | |
| base = ' ' + formatError(value); | |
| } | |
| if (keys.length === 0 && (!array || value.length == 0)) { | |
| return braces[0] + base + braces[1]; | |
| } | |
| if (recurseTimes < 0) { | |
| if (isRegExp(value)) { | |
| return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | |
| } else { | |
| return ctx.stylize('[Object]', 'special'); | |
| } | |
| } | |
| ctx.seen.push(value); | |
| var output; | |
| if (array) { | |
| output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); | |
| } else { | |
| output = keys.map(function(key) { | |
| return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); | |
| }); | |
| } | |
| ctx.seen.pop(); | |
| return reduceToSingleString(output, base, braces); | |
| } | |
| function formatPrimitive(ctx, value) { | |
| if (isUndefined(value)) | |
| return ctx.stylize('undefined', 'undefined'); | |
| if (isString(value)) { | |
| var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') | |
| .replace(/'/g, "\\'") | |
| .replace(/\\"/g, '"') + '\''; | |
| return ctx.stylize(simple, 'string'); | |
| } | |
| if (isNumber(value)) | |
| return ctx.stylize('' + value, 'number'); | |
| if (isBoolean(value)) | |
| return ctx.stylize('' + value, 'boolean'); | |
| // For some reason typeof null is "object", so special case here. | |
| if (isNull(value)) | |
| return ctx.stylize('null', 'null'); | |
| } | |
| function formatError(value) { | |
| return '[' + Error.prototype.toString.call(value) + ']'; | |
| } | |
| function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { | |
| var output = []; | |
| for (var i = 0, l = value.length; i < l; ++i) { | |
| if (hasOwnProperty(value, String(i))) { | |
| output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | |
| String(i), true)); | |
| } else { | |
| output.push(''); | |
| } | |
| } | |
| keys.forEach(function(key) { | |
| if (!key.match(/^\d+$/)) { | |
| output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | |
| key, true)); | |
| } | |
| }); | |
| return output; | |
| } | |
| function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { | |
| var name, str, desc; | |
| desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; | |
| if (desc.get) { | |
| if (desc.set) { | |
| str = ctx.stylize('[Getter/Setter]', 'special'); | |
| } else { | |
| str = ctx.stylize('[Getter]', 'special'); | |
| } | |
| } else { | |
| if (desc.set) { | |
| str = ctx.stylize('[Setter]', 'special'); | |
| } | |
| } | |
| if (!hasOwnProperty(visibleKeys, key)) { | |
| name = '[' + key + ']'; | |
| } | |
| if (!str) { | |
| if (ctx.seen.indexOf(desc.value) < 0) { | |
| if (isNull(recurseTimes)) { | |
| str = formatValue(ctx, desc.value, null); | |
| } else { | |
| str = formatValue(ctx, desc.value, recurseTimes - 1); | |
| } | |
| if (str.indexOf('\n') > -1) { | |
| if (array) { | |
| str = str.split('\n').map(function(line) { | |
| return ' ' + line; | |
| }).join('\n').substr(2); | |
| } else { | |
| str = '\n' + str.split('\n').map(function(line) { | |
| return ' ' + line; | |
| }).join('\n'); | |
| } | |
| } | |
| } else { | |
| str = ctx.stylize('[Circular]', 'special'); | |
| } | |
| } | |
| if (isUndefined(name)) { | |
| if (array && key.match(/^\d+$/)) { | |
| return str; | |
| } | |
| name = JSON.stringify('' + key); | |
| if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { | |
| name = name.substr(1, name.length - 2); | |
| name = ctx.stylize(name, 'name'); | |
| } else { | |
| name = name.replace(/'/g, "\\'") | |
| .replace(/\\"/g, '"') | |
| .replace(/(^"|"$)/g, "'"); | |
| name = ctx.stylize(name, 'string'); | |
| } | |
| } | |
| return name + ': ' + str; | |
| } | |
| function reduceToSingleString(output, base, braces) { | |
| var numLinesEst = 0; | |
| var length = output.reduce(function(prev, cur) { | |
| numLinesEst++; | |
| if (cur.indexOf('\n') >= 0) numLinesEst++; | |
| return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; | |
| }, 0); | |
| if (length > 60) { | |
| return braces[0] + | |
| (base === '' ? '' : base + '\n ') + | |
| ' ' + | |
| output.join(',\n ') + | |
| ' ' + | |
| braces[1]; | |
| } | |
| return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; | |
| } | |
| // NOTE: These type checking functions intentionally don't use `instanceof` | |
| // because it is fragile and can be easily faked with `Object.create()`. | |
| function isArray(ar) { | |
| return Array.isArray(ar); | |
| } | |
| exports.isArray = isArray; | |
| function isBoolean(arg) { | |
| return typeof arg === 'boolean'; | |
| } | |
| exports.isBoolean = isBoolean; | |
| function isNull(arg) { | |
| return arg === null; | |
| } | |
| exports.isNull = isNull; | |
| function isNullOrUndefined(arg) { | |
| return arg == null; | |
| } | |
| exports.isNullOrUndefined = isNullOrUndefined; | |
| function isNumber(arg) { | |
| return typeof arg === 'number'; | |
| } | |
| exports.isNumber = isNumber; | |
| function isString(arg) { | |
| return typeof arg === 'string'; | |
| } | |
| exports.isString = isString; | |
| function isSymbol(arg) { | |
| return typeof arg === 'symbol'; | |
| } | |
| exports.isSymbol = isSymbol; | |
| function isUndefined(arg) { | |
| return arg === void 0; | |
| } | |
| exports.isUndefined = isUndefined; | |
| function isRegExp(re) { | |
| return isObject(re) && objectToString(re) === '[object RegExp]'; | |
| } | |
| exports.isRegExp = isRegExp; | |
| function isObject(arg) { | |
| return typeof arg === 'object' && arg !== null; | |
| } | |
| exports.isObject = isObject; | |
| function isDate(d) { | |
| return isObject(d) && objectToString(d) === '[object Date]'; | |
| } | |
| exports.isDate = isDate; | |
| function isError(e) { | |
| return isObject(e) && | |
| (objectToString(e) === '[object Error]' || e instanceof Error); | |
| } | |
| exports.isError = isError; | |
| function isFunction(arg) { | |
| return typeof arg === 'function'; | |
| } | |
| exports.isFunction = isFunction; | |
| function isPrimitive(arg) { | |
| return arg === null || | |
| typeof arg === 'boolean' || | |
| typeof arg === 'number' || | |
| typeof arg === 'string' || | |
| typeof arg === 'symbol' || // ES6 symbol | |
| typeof arg === 'undefined'; | |
| } | |
| exports.isPrimitive = isPrimitive; | |
| exports.isBuffer = require('./support/isBuffer'); | |
| function objectToString(o) { | |
| return Object.prototype.toString.call(o); | |
| } | |
| function pad(n) { | |
| return n < 10 ? '0' + n.toString(10) : n.toString(10); | |
| } | |
| var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', | |
| 'Oct', 'Nov', 'Dec']; | |
| // 26 Feb 16:19:34 | |
| function timestamp() { | |
| var d = new Date(); | |
| var time = [pad(d.getHours()), | |
| pad(d.getMinutes()), | |
| pad(d.getSeconds())].join(':'); | |
| return [d.getDate(), months[d.getMonth()], time].join(' '); | |
| } | |
| // log is just a thin wrapper to console.log that prepends a timestamp | |
| exports.log = function() { | |
| console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); | |
| }; | |
| /** | |
| * Inherit the prototype methods from one constructor into another. | |
| * | |
| * The Function.prototype.inherits from lang.js rewritten as a standalone | |
| * function (not on Function.prototype). NOTE: If this file is to be loaded | |
| * during bootstrapping this function needs to be rewritten using some native | |
| * functions as prototype setup using normal JavaScript does not work as | |
| * expected during bootstrapping (see mirror.js in r114903). | |
| * | |
| * @param {function} ctor Constructor function which needs to inherit the | |
| * prototype. | |
| * @param {function} superCtor Constructor function to inherit prototype from. | |
| */ | |
| exports.inherits = require('inherits'); | |
| exports._extend = function(origin, add) { | |
| // Don't do anything if add isn't an object | |
| if (!add || !isObject(add)) return origin; | |
| var keys = Object.keys(add); | |
| var i = keys.length; | |
| while (i--) { | |
| origin[keys[i]] = add[keys[i]]; | |
| } | |
| return origin; | |
| }; | |
| function hasOwnProperty(obj, prop) { | |
| return Object.prototype.hasOwnProperty.call(obj, prop); | |
| } | |
| }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
| },{"./support/isBuffer":5,"_process":3,"inherits":4}],7:[function(require,module,exports){ | |
| module.exports = applyHook | |
| // apply arguments onto an array of functions, useful for hooks | |
| // (arr, any?, any?, any?, any?, any?) -> null | |
| function applyHook (arr, arg1, arg2, arg3, arg4, arg5) { | |
| arr.forEach(function (fn) { | |
| fn(arg1, arg2, arg3, arg4, arg5) | |
| }) | |
| } | |
| },{}],8:[function(require,module,exports){ | |
| var mutate = require('xtend/mutable') | |
| var nanotick = require('nanotick') | |
| var assert = require('assert') | |
| var xtend = require('xtend') | |
| var applyHook = require('./apply-hook') | |
| module.exports = dispatcher | |
| // initialize a new barracks instance | |
| // obj -> obj | |
| function dispatcher (hooks) { | |
| hooks = hooks || {} | |
| assert.equal(typeof hooks, 'object', 'barracks: hooks should be undefined or an object') | |
| var onStateChangeHooks = [] | |
| var onActionHooks = [] | |
| var onErrorHooks = [] | |
| var subscriptionWraps = [] | |
| var initialStateWraps = [] | |
| var reducerWraps = [] | |
| var effectWraps = [] | |
| use(hooks) | |
| var reducersCalled = false | |
| var effectsCalled = false | |
| var stateCalled = false | |
| var subsCalled = false | |
| var stopped = false | |
| var subscriptions = start._subscriptions = {} | |
| var reducers = start._reducers = {} | |
| var effects = start._effects = {} | |
| var models = start._models = [] | |
| var _state = {} | |
| var tick = nanotick() | |
| start.model = setModel | |
| start.state = getState | |
| start.start = start | |
| start.stop = stop | |
| start.use = use | |
| return start | |
| // push an object of hooks onto an array | |
| // obj -> null | |
| function use (hooks) { | |
| assert.equal(typeof hooks, 'object', 'barracks.use: hooks should be an object') | |
| assert.ok(!hooks.onError || typeof hooks.onError === 'function', 'barracks.use: onError should be undefined or a function') | |
| assert.ok(!hooks.onAction || typeof hooks.onAction === 'function', 'barracks.use: onAction should be undefined or a function') | |
| assert.ok(!hooks.onStateChange || typeof hooks.onStateChange === 'function', 'barracks.use: onStateChange should be undefined or a function') | |
| if (hooks.onStateChange) onStateChangeHooks.push(hooks.onStateChange) | |
| if (hooks.onError) onErrorHooks.push(wrapOnError(hooks.onError)) | |
| if (hooks.onAction) onActionHooks.push(hooks.onAction) | |
| if (hooks.wrapSubscriptions) subscriptionWraps.push(hooks.wrapSubscriptions) | |
| if (hooks.wrapInitialState) initialStateWraps.push(hooks.wrapInitialState) | |
| if (hooks.wrapReducers) reducerWraps.push(hooks.wrapReducers) | |
| if (hooks.wrapEffects) effectWraps.push(hooks.wrapEffects) | |
| if (hooks.models) hooks.models.forEach(setModel) | |
| } | |
| // push a model to be initiated | |
| // obj -> null | |
| function setModel (model) { | |
| assert.equal(typeof model, 'object', 'barracks.store.model: model should be an object') | |
| models.push(model) | |
| } | |
| // get the current state from the store | |
| // obj? -> obj | |
| function getState (opts) { | |
| opts = opts || {} | |
| assert.equal(typeof opts, 'object', 'barracks.store.state: opts should be an object') | |
| var state = opts.state | |
| if (!opts.state && opts.freeze === false) return xtend(_state) | |
| else if (!opts.state) return Object.freeze(xtend(_state)) | |
| assert.equal(typeof state, 'object', 'barracks.store.state: state should be an object') | |
| var namespaces = [] | |
| var newState = {} | |
| // apply all fields from the model, and namespaced fields from the passed | |
| // in state | |
| models.forEach(function (model) { | |
| var ns = model.namespace | |
| namespaces.push(ns) | |
| var modelState = model.state || {} | |
| if (ns) { | |
| newState[ns] = newState[ns] || {} | |
| apply(ns, modelState, newState) | |
| newState[ns] = xtend(newState[ns], state[ns]) | |
| } else { | |
| mutate(newState, modelState) | |
| } | |
| }) | |
| // now apply all fields that weren't namespaced from the passed in state | |
| Object.keys(state).forEach(function (key) { | |
| if (namespaces.indexOf(key) !== -1) return | |
| newState[key] = state[key] | |
| }) | |
| var tmpState = xtend(_state, xtend(state, newState)) | |
| var wrappedState = wrapHook(tmpState, initialStateWraps) | |
| return (opts.freeze === false) | |
| ? wrappedState | |
| : Object.freeze(wrappedState) | |
| } | |
| // initialize the store hooks, get the send() function | |
| // obj? -> fn | |
| function start (opts) { | |
| opts = opts || {} | |
| assert.equal(typeof opts, 'object', 'barracks.store.start: opts should be undefined or an object') | |
| // register values from the models | |
| models.forEach(function (model) { | |
| var ns = model.namespace | |
| if (!stateCalled && model.state && opts.state !== false) { | |
| var modelState = model.state || {} | |
| if (ns) { | |
| _state[ns] = _state[ns] || {} | |
| apply(ns, modelState, _state) | |
| } else { | |
| mutate(_state, modelState) | |
| } | |
| } | |
| if (!reducersCalled && model.reducers && opts.reducers !== false) { | |
| apply(ns, model.reducers, reducers, function (cb) { | |
| return wrapHook(cb, reducerWraps) | |
| }) | |
| } | |
| if (!effectsCalled && model.effects && opts.effects !== false) { | |
| apply(ns, model.effects, effects, function (cb) { | |
| return wrapHook(cb, effectWraps) | |
| }) | |
| } | |
| if (!subsCalled && model.subscriptions && opts.subscriptions !== false) { | |
| apply(ns, model.subscriptions, subscriptions, function (cb, key) { | |
| var send = createSend('subscription: ' + (ns ? ns + ':' + key : key)) | |
| cb = wrapHook(cb, subscriptionWraps) | |
| cb(send, function (err) { | |
| applyHook(onErrorHooks, err, _state, createSend) | |
| }) | |
| return cb | |
| }) | |
| } | |
| }) | |
| // the state wrap is special because we want to operate on the full | |
| // state rather than indvidual chunks, so we apply it outside the loop | |
| if (!stateCalled && opts.state !== false) { | |
| _state = wrapHook(_state, initialStateWraps) | |
| if (onStateChangeHooks.length) { | |
| applyHook(onStateChangeHooks, _state, {}, {}, 'init', createSend) | |
| } | |
| } | |
| if (!opts.noSubscriptions) subsCalled = true | |
| if (!opts.noReducers) reducersCalled = true | |
| if (!opts.noEffects) effectsCalled = true | |
| if (!opts.noState) stateCalled = true | |
| if (!onErrorHooks.length) onErrorHooks.push(wrapOnError(defaultOnError)) | |
| return createSend | |
| // call an action from a view | |
| // (str, bool?) -> (str, any?, fn?) -> null | |
| function createSend (selfName, callOnError) { | |
| assert.equal(typeof selfName, 'string', 'barracks.store.start.createSend: selfName should be a string') | |
| assert.ok(!callOnError || typeof callOnError === 'boolean', 'barracks.store.start.send: callOnError should be undefined or a boolean') | |
| return function send (name, data, cb) { | |
| if (!cb && !callOnError) { | |
| cb = data | |
| data = null | |
| } | |
| data = (typeof data === 'undefined' ? null : data) | |
| assert.equal(typeof name, 'string', 'barracks.store.start.send: name should be a string') | |
| assert.ok(!cb || typeof cb === 'function', 'barracks.store.start.send: cb should be a function') | |
| var done = callOnError ? onErrorCallback : cb | |
| _send(name, data, selfName, done) | |
| function onErrorCallback (err) { | |
| err = err || null | |
| if (err) { | |
| applyHook(onErrorHooks, err, _state, function createSend (selfName) { | |
| return function send (name, data) { | |
| assert.equal(typeof name, 'string', 'barracks.store.start.send: name should be a string') | |
| data = (typeof data === 'undefined' ? null : data) | |
| _send(name, data, selfName, done) | |
| } | |
| }) | |
| } | |
| } | |
| } | |
| } | |
| // call an action | |
| // (str, str, any, fn) -> null | |
| function _send (name, data, caller, cb) { | |
| if (stopped) return | |
| assert.equal(typeof name, 'string', 'barracks._send: name should be a string') | |
| assert.equal(typeof caller, 'string', 'barracks._send: caller should be a string') | |
| assert.equal(typeof cb, 'function', 'barracks._send: cb should be a function') | |
| ;(tick(function () { | |
| var reducersCalled = false | |
| var effectsCalled = false | |
| var newState = xtend(_state) | |
| if (onActionHooks.length) { | |
| applyHook(onActionHooks, _state, data, name, caller, createSend) | |
| } | |
| // validate if a namespace exists. Namespaces are delimited by ':'. | |
| var actionName = name | |
| if (/:/.test(name)) { | |
| var arr = name.split(':') | |
| var ns = arr.shift() | |
| actionName = arr.join(':') | |
| } | |
| var _reducers = ns ? reducers[ns] : reducers | |
| if (_reducers && _reducers[actionName]) { | |
| if (ns) { | |
| var reducedState = _reducers[actionName](_state[ns], data) | |
| newState[ns] = xtend(_state[ns], reducedState) | |
| } else { | |
| mutate(newState, reducers[actionName](_state, data)) | |
| } | |
| reducersCalled = true | |
| if (onStateChangeHooks.length) { | |
| applyHook(onStateChangeHooks, newState, data, _state, actionName, createSend) | |
| } | |
| _state = newState | |
| cb(null, newState) | |
| } | |
| var _effects = ns ? effects[ns] : effects | |
| if (!reducersCalled && _effects && _effects[actionName]) { | |
| var send = createSend('effect: ' + name) | |
| if (ns) _effects[actionName](_state[ns], data, send, cb) | |
| else _effects[actionName](_state, data, send, cb) | |
| effectsCalled = true | |
| } | |
| if (!reducersCalled && !effectsCalled) { | |
| throw new Error('Could not find action ' + actionName) | |
| } | |
| }))() | |
| } | |
| } | |
| // stop an app, essentially turns | |
| // all send() calls into no-ops. | |
| // () -> null | |
| function stop () { | |
| stopped = true | |
| } | |
| } | |
| // compose an object conditionally | |
| // optionally contains a namespace | |
| // which is used to nest properties. | |
| // (str, obj, obj, fn?) -> null | |
| function apply (ns, source, target, wrap) { | |
| if (ns && !target[ns]) target[ns] = {} | |
| Object.keys(source).forEach(function (key) { | |
| var cb = wrap ? wrap(source[key], key) : source[key] | |
| if (ns) target[ns][key] = cb | |
| else target[key] = cb | |
| }) | |
| } | |
| // handle errors all the way at the top of the trace | |
| // err? -> null | |
| function defaultOnError (err) { | |
| throw err | |
| } | |
| function wrapOnError (onError) { | |
| return function onErrorWrap (err, state, createSend) { | |
| if (err) onError(err, state, createSend) | |
| } | |
| } | |
| // take a apply an array of transforms onto a value. The new value | |
| // must be returned synchronously from the transform | |
| // (any, [fn]) -> any | |
| function wrapHook (value, transforms) { | |
| transforms.forEach(function (transform) { | |
| value = transform(value) | |
| }) | |
| return value | |
| } | |
| },{"./apply-hook":7,"assert":1,"nanotick":9,"xtend":23,"xtend/mutable":24}],9:[function(require,module,exports){ | |
| /* eslint-disable no-eval */ | |
| var assert = require('assert') | |
| module.exports = nanotick | |
| var delay = (typeof window !== 'undefined' && window.document) | |
| ? (typeof setImmediate !== 'undefined') | |
| ? setImmediate | |
| : setTimeout | |
| : eval('process.nextTick') | |
| // Process.nextTick() batching ulity | |
| // null -> fn(any) -> fn(any) | |
| function nanotick () { | |
| var callbacks = [] | |
| var interval = false | |
| return function tick (cb) { | |
| assert.equal(typeof cb, 'function', 'nanotick.tick: cb should be a function') | |
| var isAsync = false | |
| executeAsync(function () { | |
| isAsync = true | |
| }) | |
| return function wrappedTick () { | |
| var length = arguments.length | |
| var args = [] | |
| for (var i = 0; i < length; i++) { | |
| args.push[arguments[i]] | |
| } | |
| if (isAsync) { | |
| cb.apply(cb, args) | |
| } else { | |
| executeAsync(function () { | |
| cb.apply(cb, args) | |
| }) | |
| } | |
| } | |
| } | |
| function executeAsync (cb) { | |
| callbacks.push(cb) | |
| if (!interval) { | |
| interval = true | |
| delay(function () { | |
| while (callbacks.length > 0) { | |
| callbacks.shift()() | |
| } | |
| interval = false | |
| }) | |
| } | |
| } | |
| } | |
| },{"assert":1}],10:[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 : {}) | |
| },{"min-document":2}],11:[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 : {}) | |
| },{}],12:[function(require,module,exports){ | |
| var window = require('global/window') | |
| var assert = require('assert') | |
| module.exports = nanoraf | |
| // Only call RAF when needed | |
| // (fn, fn?) -> fn | |
| function nanoraf (render, raf) { | |
| assert.equal(typeof render, 'function', 'nanoraf: render should be a function') | |
| assert.ok(typeof raf === 'function' || typeof raf === 'undefined', 'nanoraf: raf should be a function or undefined') | |
| if (!raf) raf = window.requestAnimationFrame | |
| var inRenderingTransaction = false | |
| var redrawScheduled = false | |
| var currentState = null | |
| // pass new state to be rendered | |
| // (obj, obj?) -> null | |
| return function frame (state, prev) { | |
| assert.equal(typeof state, 'object', 'nanoraf: state should be an object') | |
| assert.equal(typeof prev, 'object', 'nanoraf: prev should be an object') | |
| assert.equal(inRenderingTransaction, false, 'nanoraf: infinite loop detected') | |
| // request a redraw for next frame | |
| if (currentState === null && !redrawScheduled) { | |
| redrawScheduled = true | |
| raf(function redraw () { | |
| redrawScheduled = false | |
| if (!currentState) return | |
| inRenderingTransaction = true | |
| render(currentState, prev) | |
| inRenderingTransaction = false | |
| currentState = null | |
| }) | |
| } | |
| // update data for redraw | |
| currentState = state | |
| } | |
| } | |
| },{"assert":1,"global/window":11}],13:[function(require,module,exports){ | |
| /* eslint-disable no-useless-escape */ | |
| var electron = '^(file:\/\/|\/)(.*\.html?\/?)?' | |
| var protocol = '^(http(s)?(:\/\/))?(www\.)?' | |
| var domain = '[a-zA-Z0-9-_\.]+(:[0-9]{1,5})?(\/{1})?' | |
| var qs = '[\?].*$' | |
| /* eslint-enable no-useless-escape */ | |
| var stripElectron = new RegExp(electron) | |
| var prefix = new RegExp(protocol + domain) | |
| var normalize = new RegExp('#') | |
| var suffix = new RegExp(qs) | |
| module.exports = pathname | |
| // replace everything in a route but the pathname and hash | |
| // TODO(yw): ditch 'suffix' and allow qs routing | |
| // (str, bool) -> str | |
| function pathname (route, isElectron) { | |
| if (isElectron) route = route.replace(stripElectron, '') | |
| else route = route.replace(prefix, '') | |
| return route.replace(suffix, '').replace(normalize, '/') | |
| } | |
| },{}],14:[function(require,module,exports){ | |
| var document = require('global/document') | |
| var assert = require('assert') | |
| var xtend = require('xtend') | |
| var qs = require('./qs') | |
| module.exports = createLocation | |
| // takes an initial representation of the location state | |
| // and then synchronize a mutation across all fields | |
| // | |
| // scenarios: | |
| // - create a state object from document.location; we got no state yet | |
| // - create a new state object from a string we pass in; full override mode | |
| // - patch a state object with some value we pass in - lil patchy stuff | |
| // | |
| // (obj?, str?) -> obj | |
| function createLocation (state, patch) { | |
| if (!state) { | |
| return { | |
| pathname: document.location.pathname, | |
| search: (document.location.search) ? qs(document.location.search) : {}, | |
| hash: document.location.hash, | |
| href: document.location.href | |
| } | |
| } else { | |
| assert.equal(typeof state, 'object', 'sheet-router/create-location: state should be an object') | |
| if (typeof patch === 'string') { | |
| return parseUrl(patch) | |
| } else { | |
| assert.equal(typeof patch, 'object', 'sheet-router/create-location: patch should be an object') | |
| return xtend(state, patch) | |
| } | |
| } | |
| // parse a URL into a kv object inside the browser | |
| // str -> obj | |
| function parseUrl (url) { | |
| var a = document.createElement('a') | |
| a.href = url | |
| return { | |
| href: a.href, | |
| pathname: a.pathname, | |
| search: (a.search) ? qs(a.search) : {}, | |
| hash: a.hash | |
| } | |
| } | |
| } | |
| },{"./qs":21,"assert":1,"global/document":10,"xtend":23}],15:[function(require,module,exports){ | |
| var document = require('global/document') | |
| var window = require('global/window') | |
| var assert = require('assert') | |
| module.exports = history | |
| // listen to html5 pushstate events | |
| // and update router accordingly | |
| // fn(str) -> null | |
| function history (cb) { | |
| assert.equal(typeof cb, 'function', 'sheet-router/history: cb must be a function') | |
| window.onpopstate = function () { | |
| cb({ | |
| pathname: document.location.pathname, | |
| search: document.location.search, | |
| href: document.location.href, | |
| hash: document.location.hash | |
| }) | |
| } | |
| } | |
| },{"assert":1,"global/document":10,"global/window":11}],16:[function(require,module,exports){ | |
| var window = require('global/window') | |
| var assert = require('assert') | |
| var qs = require('./qs') | |
| module.exports = href | |
| var noRoutingAttrName = 'data-no-routing' | |
| // handle a click if is anchor tag with an href | |
| // and url lives on the same domain. Replaces | |
| // trailing '#' so empty links work as expected. | |
| // (fn(str), obj?) -> undefined | |
| function href (cb, root) { | |
| assert.equal(typeof cb, 'function', 'sheet-router/href: cb must be a function') | |
| window.onclick = function (e) { | |
| if ((e.button && e.button !== 0) || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return | |
| var node = (function traverse (node) { | |
| if (!node || node === root) return | |
| if (node.localName !== 'a') return traverse(node.parentNode) | |
| if (node.href === undefined) return traverse(node.parentNode) | |
| if (window.location.host !== node.host) return traverse(node.parentNode) | |
| return node | |
| })(e.target) | |
| if (!node) return | |
| var isRoutingDisabled = node.hasAttribute(noRoutingAttrName) | |
| if (isRoutingDisabled) return | |
| e.preventDefault() | |
| cb({ | |
| pathname: node.pathname, | |
| search: (node.search) ? qs(node.search) : {}, | |
| href: node.href, | |
| hash: node.hash | |
| }) | |
| } | |
| } | |
| },{"./qs":21,"assert":1,"global/window":11}],17:[function(require,module,exports){ | |
| var pathname = require('./_pathname') | |
| var wayfarer = require('wayfarer') | |
| var assert = require('assert') | |
| var isLocalFile = (/file:\/\//.test(typeof window === 'object' && | |
| window.location && window.location.origin)) // electron support | |
| module.exports = sheetRouter | |
| // Fast, modular client router | |
| // fn(str, any[..]) -> fn(str, any[..]) | |
| function sheetRouter (opts, tree) { | |
| if (!tree) { | |
| tree = opts | |
| opts = {} | |
| } | |
| assert.equal(typeof opts, 'object', 'sheet-router: opts must be a object') | |
| assert.ok(Array.isArray(tree), 'sheet-router: tree must be an array') | |
| var dft = opts.default || '/404' | |
| assert.equal(typeof dft, 'string', 'sheet-router: dft must be a string') | |
| var router = wayfarer(dft) | |
| var prevCallback = null | |
| var prevRoute = null | |
| match._router = router | |
| // register tree in router | |
| // tree[0] is a string, thus a route | |
| // tree[0] is an array, thus not a route | |
| // tree[1] is a function | |
| // tree[2] is an array | |
| // tree[2] is not an array | |
| // tree[1] is an array | |
| ;(function walk (tree, fullRoute) { | |
| if (typeof tree[0] === 'string') { | |
| var route = tree[0].replace(/^[#/]/, '') | |
| } else { | |
| var rootArr = tree[0] | |
| } | |
| var cb = (typeof tree[1] === 'function') ? tree[1] : null | |
| var children = (Array.isArray(tree[1])) | |
| ? tree[1] | |
| : Array.isArray(tree[2]) ? tree[2] : null | |
| if (rootArr) { | |
| tree.forEach(function (node) { | |
| walk(node, fullRoute) | |
| }) | |
| } | |
| if (cb) { | |
| var innerRoute = route | |
| ? fullRoute.concat(route).join('/') | |
| : fullRoute.length ? fullRoute.join('/') : route | |
| // if opts.thunk is false or only enabled for match, don't thunk | |
| var handler = (opts.thunk === false || opts.thunk === 'match') | |
| ? cb | |
| : thunkify(cb) | |
| router.on(innerRoute, handler) | |
| } | |
| if (Array.isArray(children)) { | |
| walk(children, fullRoute.concat(route)) | |
| } | |
| })(tree, []) | |
| return match | |
| // match a route on the router | |
| // | |
| // no thunking -> call route with all arguments | |
| // thunking only for match -> call route with all arguments | |
| // thunking and route is same -> call prev cb with new args | |
| // thunking and route is diff -> create cb and call with new args | |
| // | |
| // (str, [any..]) -> any | |
| function match (route, arg1, arg2, arg3, arg4, arg5) { | |
| assert.equal(typeof route, 'string', 'sheet-router: route must be a string') | |
| if (opts.thunk === false) { | |
| return router(pathname(route, isLocalFile), arg1, arg2, arg3, arg4, arg5) | |
| } else if (route === prevRoute) { | |
| return prevCallback(arg1, arg2, arg3, arg4, arg5) | |
| } else { | |
| prevRoute = pathname(route, isLocalFile) | |
| prevCallback = router(prevRoute) | |
| return prevCallback(arg1, arg2, arg3, arg4, arg5) | |
| } | |
| } | |
| } | |
| // wrap a function in a function so it can be called at a later time | |
| // fn -> obj -> (any, any, any, any, any) | |
| function thunkify (cb) { | |
| return function (params) { | |
| return function (arg1, arg2, arg3, arg4, arg5) { | |
| return cb(params, arg1, arg2, arg3, arg4, arg5) | |
| } | |
| } | |
| } | |
| },{"./_pathname":13,"assert":1,"wayfarer":18}],18:[function(require,module,exports){ | |
| const assert = require('assert') | |
| const trie = require('./trie') | |
| module.exports = Wayfarer | |
| // create a router | |
| // str -> obj | |
| function Wayfarer (dft) { | |
| if (!(this instanceof Wayfarer)) return new Wayfarer(dft) | |
| const _default = (dft || '').replace(/^\//, '') | |
| const _trie = trie() | |
| emit._trie = _trie | |
| emit.emit = emit | |
| emit.on = on | |
| emit._wayfarer = true | |
| return emit | |
| // define a route | |
| // (str, fn) -> obj | |
| function on (route, cb) { | |
| assert.equal(typeof route, 'string') | |
| assert.equal(typeof cb, 'function') | |
| route = route || '/' | |
| if (cb && cb._wayfarer && cb._trie) { | |
| _trie.mount(route, cb._trie.trie) | |
| } else { | |
| const node = _trie.create(route) | |
| node.cb = cb | |
| } | |
| return emit | |
| } | |
| // match and call a route | |
| // (str, obj?) -> null | |
| function emit (route) { | |
| assert.notEqual(route, undefined, "'route' must be defined") | |
| const args = new Array(arguments.length) | |
| for (var i = 1; i < args.length; i++) { | |
| args[i] = arguments[i] | |
| } | |
| const node = _trie.match(route) | |
| if (node && node.cb) { | |
| args[0] = node.params | |
| return node.cb.apply(null, args) | |
| } | |
| const dft = _trie.match(_default) | |
| if (dft && dft.cb) { | |
| args[0] = dft.params | |
| return dft.cb.apply(null, args) | |
| } | |
| throw new Error("route '" + route + "' did not match") | |
| } | |
| } | |
| },{"./trie":19,"assert":1}],19:[function(require,module,exports){ | |
| const mutate = require('xtend/mutable') | |
| const assert = require('assert') | |
| const xtend = require('xtend') | |
| module.exports = Trie | |
| // create a new trie | |
| // null -> obj | |
| function Trie () { | |
| if (!(this instanceof Trie)) return new Trie() | |
| this.trie = { nodes: {} } | |
| } | |
| // create a node on the trie at route | |
| // and return a node | |
| // str -> null | |
| Trie.prototype.create = function (route) { | |
| assert.equal(typeof route, 'string', 'route should be a string') | |
| // strip leading '/' and split routes | |
| const routes = route.replace(/^\//, '').split('/') | |
| return (function createNode (index, trie, routes) { | |
| const route = routes[index] | |
| if (route === undefined) return trie | |
| var node = null | |
| if (/^:/.test(route)) { | |
| // if node is a name match, set name and append to ':' node | |
| if (!trie.nodes['$$']) { | |
| node = { nodes: {} } | |
| trie.nodes['$$'] = node | |
| } else { | |
| node = trie.nodes['$$'] | |
| } | |
| trie.name = route.replace(/^:/, '') | |
| } else if (!trie.nodes[route]) { | |
| node = { nodes: {} } | |
| trie.nodes[route] = node | |
| } else { | |
| node = trie.nodes[route] | |
| } | |
| // we must recurse deeper | |
| return createNode(index + 1, node, routes) | |
| })(0, this.trie, routes) | |
| } | |
| // match a route on the trie | |
| // and return the node | |
| // str -> obj | |
| Trie.prototype.match = function (route) { | |
| assert.equal(typeof route, 'string', 'route should be a string') | |
| const routes = route.replace(/^\//, '').split('/') | |
| const params = {} | |
| var node = (function search (index, trie) { | |
| // either there's no match, or we're done searching | |
| if (trie === undefined) return undefined | |
| const route = routes[index] | |
| if (route === undefined) return trie | |
| if (trie.nodes[route]) { | |
| // match regular routes first | |
| return search(index + 1, trie.nodes[route]) | |
| } else if (trie.name) { | |
| // match named routes | |
| params[trie.name] = decodeURIComponent(route) | |
| return search(index + 1, trie.nodes['$$']) | |
| } else { | |
| // no matches found | |
| return search(index + 1) | |
| } | |
| })(0, this.trie) | |
| if (!node) return undefined | |
| node = xtend(node) | |
| node.params = params | |
| return node | |
| } | |
| // mount a trie onto a node at route | |
| // (str, obj) -> null | |
| Trie.prototype.mount = function (route, trie) { | |
| assert.equal(typeof route, 'string', 'route should be a string') | |
| assert.equal(typeof trie, 'object', 'trie should be a object') | |
| const split = route.replace(/^\//, '').split('/') | |
| var node = null | |
| var key = null | |
| if (split.length === 1) { | |
| key = split[0] | |
| node = this.create(key) | |
| } else { | |
| const headArr = split.splice(0, split.length - 1) | |
| const head = headArr.join('/') | |
| key = split[0] | |
| node = this.create(head) | |
| } | |
| mutate(node.nodes, trie.nodes) | |
| if (trie.name) node.name = trie.name | |
| // delegate properties from '/' to the new node | |
| // '/' cannot be reached once mounted | |
| if (node.nodes['']) { | |
| Object.keys(node.nodes['']).forEach(function (key) { | |
| if (key === 'nodes') return | |
| node[key] = node.nodes[''][key] | |
| }) | |
| mutate(node.nodes, node.nodes[''].nodes) | |
| delete node.nodes[''].nodes | |
| } | |
| } | |
| },{"assert":1,"xtend":23,"xtend/mutable":24}],20:[function(require,module,exports){ | |
| const assert = require('assert') | |
| module.exports = walk | |
| // walk a wayfarer trie | |
| // (obj, fn) -> null | |
| function walk (router, transform) { | |
| assert.equal(typeof router, 'function', 'wayfarer.walk: router should be an function') | |
| assert.equal(typeof transform, 'function', 'wayfarer.walk: transform should be a function') | |
| const trie = router._trie | |
| assert.equal(typeof trie, 'object', 'wayfarer.walk: trie should be an object') | |
| // (str, obj) -> null | |
| ;(function walk (route, trie) { | |
| if (trie.cb) { | |
| trie.cb = transform(route, trie.cb) | |
| } | |
| if (trie.nodes) { | |
| const nodes = trie.nodes | |
| Object.keys(nodes).forEach(function (key) { | |
| const node = nodes[key] | |
| const newRoute = (key === '$$') | |
| ? route + '/:' + trie.name | |
| : route + '/' + key | |
| walk(newRoute, node) | |
| }) | |
| } | |
| })('', trie.trie) | |
| } | |
| },{"assert":1}],21:[function(require,module,exports){ | |
| var window = require('global/window') | |
| var decodeURIComponent = window.decodeURIComponent | |
| var reg = new RegExp('([^?=&]+)(=([^&]*))?', 'g') | |
| module.exports = qs | |
| // decode a uri into a kv representation :: str -> obj | |
| function qs (uri) { | |
| var obj = {} | |
| uri.replace(/^.*\?/, '').replace(reg, map) | |
| return obj | |
| function map (a0, a1, a2, a3) { | |
| obj[decodeURIComponent(a1)] = decodeURIComponent(a3) | |
| } | |
| } | |
| },{"global/window":11}],22:[function(require,module,exports){ | |
| const walk = require('wayfarer/walk') | |
| const assert = require('assert') | |
| module.exports = walkSheetRouter | |
| function walkSheetRouter (router, cb) { | |
| assert.equal(typeof router, 'function', 'sheet-router/walk: router should be a function') | |
| assert.equal(typeof cb, 'function', 'sheet-router/walk: cb should be a function') | |
| router = router._router | |
| return walk(router, cb) | |
| } | |
| },{"assert":1,"wayfarer/walk":20}],23:[function(require,module,exports){ | |
| module.exports = extend | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| function extend() { | |
| var target = {} | |
| for (var i = 0; i < arguments.length; i++) { | |
| var source = arguments[i] | |
| for (var key in source) { | |
| if (hasOwnProperty.call(source, key)) { | |
| target[key] = source[key] | |
| } | |
| } | |
| } | |
| return target | |
| } | |
| },{}],24:[function(require,module,exports){ | |
| module.exports = extend | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| function extend(target) { | |
| for (var i = 1; i < arguments.length; i++) { | |
| var source = arguments[i] | |
| for (var key in source) { | |
| if (hasOwnProperty.call(source, key)) { | |
| target[key] = source[key] | |
| } | |
| } | |
| } | |
| return target | |
| } | |
| },{}],25:[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 | |
| } | |
| } | |
| var oldValue = f.value | |
| var newValue = t.value | |
| // copy values for form elements | |
| if ((f.nodeName === 'INPUT' && f.type !== 'file') || f.nodeName === 'SELECT') { | |
| if (!newValue) { | |
| t.value = f.value | |
| } else if (newValue !== oldValue) { | |
| f.value = newValue | |
| } | |
| } else if (f.nodeName === 'TEXTAREA') { | |
| if (t.getAttribute('value') === null) f.value = t.value | |
| } | |
| } | |
| } | |
| },{"./update-events.js":31,"bel":26,"morphdom":30}],26:[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 XLINKNS = 'http://www.w3.org/1999/xlink' | |
| 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 belOnload () { | |
| load(el) | |
| }, function belOnunload () { | |
| 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) { | |
| if (p === 'xlink:href') { | |
| el.setAttributeNS(XLINKNS, p, val) | |
| } else if (/^xmlns($|:)/i.test(p)) { | |
| // skip xmlns definitions | |
| } else { | |
| 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.default = module.exports | |
| module.exports.createElement = belCreateElement | |
| },{"global/document":10,"hyperx":27,"on-load":29}],27:[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', '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":28}],28:[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) | |
| } | |
| } | |
| },{}],29:[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":10,"global/window":11}],30:[function(require,module,exports){ | |
| 'use strict'; | |
| var range; // Create a range object for efficently rendering strings to elements. | |
| var NS_XHTML = 'http://www.w3.org/1999/xhtml'; | |
| var doc = typeof document === 'undefined' ? undefined : document; | |
| var testEl = doc ? | |
| doc.body || doc.createElement('div') : | |
| {}; | |
| // Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32> | |
| // (IE7+ support) <=IE7 does not support el.hasAttribute(name) | |
| var actualHasAttributeNS; | |
| if (testEl.hasAttributeNS) { | |
| actualHasAttributeNS = function(el, namespaceURI, name) { | |
| return el.hasAttributeNS(namespaceURI, name); | |
| }; | |
| } else if (testEl.hasAttribute) { | |
| actualHasAttributeNS = function(el, namespaceURI, name) { | |
| return el.hasAttribute(name); | |
| }; | |
| } else { | |
| actualHasAttributeNS = function(el, namespaceURI, name) { | |
| return el.getAttributeNode(namespaceURI, name) != null; | |
| }; | |
| } | |
| var hasAttributeNS = actualHasAttributeNS; | |
| 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]; | |
| } | |
| /** | |
| * 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); | |
| } | |
| /** | |
| * 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 morphAttrs(fromNode, toNode) { | |
| var attrs = toNode.attributes; | |
| var i; | |
| var attr; | |
| var attrName; | |
| var attrNamespaceURI; | |
| var attrValue; | |
| var fromValue; | |
| 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); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| 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) { | |
| // Needed for IE. Apparently IE sets the placeholder as the | |
| // node value and vise versa. This ignores an empty update. | |
| if (newValue === '' && fromEl.firstChild.nodeValue === fromEl.placeholder) { | |
| return; | |
| } | |
| fromEl.firstChild.nodeValue = newValue; | |
| } | |
| }, | |
| SELECT: function(fromEl, toEl) { | |
| if (!hasAttributeNS(toEl, null, 'multiple')) { | |
| var selectedIndex = -1; | |
| var i = 0; | |
| var curChild = toEl.firstChild; | |
| while(curChild) { | |
| var nodeName = curChild.nodeName; | |
| if (nodeName && nodeName.toUpperCase() === 'OPTION') { | |
| if (hasAttributeNS(curChild, null, 'selected')) { | |
| selectedIndex = i; | |
| break; | |
| } | |
| i++; | |
| } | |
| curChild = curChild.nextSibling; | |
| } | |
| fromEl.selectedIndex = i; | |
| } | |
| } | |
| }; | |
| var ELEMENT_NODE = 1; | |
| var TEXT_NODE = 3; | |
| var COMMENT_NODE = 8; | |
| function noop() {} | |
| function defaultGetNodeKey(node) { | |
| return node.id; | |
| } | |
| function morphdomFactory(morphAttrs) { | |
| return 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) { | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) { | |
| curToNodeChild = toNextSibling; | |
| curFromNodeChild = fromNextSibling; | |
| continue outer; | |
| } | |
| curFromNodeKey = getNodeKey(curFromNodeChild); | |
| 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); | |
| fromNextSibling = curFromNodeChild.nextSibling; | |
| 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 = 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; | |
| }; | |
| } | |
| var morphdom = morphdomFactory(morphAttrs); | |
| module.exports = morphdom; | |
| },{}],31:[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' | |
| ] | |
| },{}],"choo":[function(require,module,exports){ | |
| const createLocation = require('sheet-router/create-location') | |
| const onHistoryChange = require('sheet-router/history') | |
| const sheetRouter = require('sheet-router') | |
| const onHref = require('sheet-router/href') | |
| const walk = require('sheet-router/walk') | |
| const mutate = require('xtend/mutable') | |
| const barracks = require('barracks') | |
| const nanoraf = require('nanoraf') | |
| const assert = require('assert') | |
| const xtend = require('xtend') | |
| const yo = require('yo-yo') | |
| module.exports = choo | |
| // framework for creating sturdy web applications | |
| // null -> fn | |
| function choo (opts) { | |
| opts = opts || {} | |
| const _store = start._store = barracks() | |
| var _router = start._router = null | |
| var _routerOpts = null | |
| var _rootNode = null | |
| var _routes = null | |
| var _frame = null | |
| if (typeof window !== 'undefined') { | |
| _store.use({ onStateChange: render }) | |
| } | |
| _store.use(opts) | |
| start.toString = toString | |
| start.router = router | |
| start.model = model | |
| start.start = start | |
| start.stop = _store.stop | |
| start.use = use | |
| return start | |
| // render the application to a string | |
| // (str, obj) -> str | |
| function toString (route, serverState) { | |
| serverState = serverState || {} | |
| assert.equal(typeof route, 'string', 'choo.app.toString: route must be a string') | |
| assert.equal(typeof serverState, 'object', 'choo.app.toString: serverState must be an object') | |
| _store.start({ subscriptions: false, reducers: false, effects: false }) | |
| const state = _store.state({ state: serverState }) | |
| const router = createRouter(_routerOpts, _routes, createSend) | |
| const tree = router(route, state) | |
| return tree.outerHTML || tree.toString() | |
| function createSend () { | |
| return function send () { | |
| assert.ok(false, 'choo: send() cannot be called from Node') | |
| } | |
| } | |
| } | |
| // start the application | |
| // (str?, obj?) -> DOMNode | |
| function start () { | |
| _store.model(createLocationModel(opts)) | |
| const createSend = _store.start(opts) | |
| _router = start._router = createRouter(_routerOpts, _routes, createSend) | |
| const state = _store.state({state: {}}) | |
| const tree = _router(state.location.href, state) | |
| assert.ok(tree, 'choo.start: the router should always return a valid DOM node') | |
| assert.equal(typeof tree, 'object', 'choo.start: the router should always return a valid DOM node') | |
| _rootNode = tree | |
| tree.done = done | |
| return tree | |
| // allow a 'mount' function to return the new node | |
| // html -> null | |
| function done (newNode) { | |
| _rootNode = newNode | |
| } | |
| } | |
| // update the DOM after every state mutation | |
| // (obj, obj, obj, str, fn) -> null | |
| function render (state, data, prev, name, createSend) { | |
| if (!_frame) { | |
| _frame = nanoraf(function (state, prev) { | |
| const newTree = _router(state.location.href, state, prev) | |
| _rootNode = yo.update(_rootNode, newTree) | |
| }) | |
| } | |
| _frame(state, prev) | |
| } | |
| // register all routes on the router | |
| // (str?, [fn|[fn]]) -> obj | |
| function router (defaultRoute, routes) { | |
| _routerOpts = defaultRoute | |
| _routes = routes | |
| } | |
| // create a new model | |
| // (str?, obj) -> null | |
| function model (model) { | |
| _store.model(model) | |
| } | |
| // register a plugin | |
| // (obj) -> null | |
| function use (hooks) { | |
| assert.equal(typeof hooks, 'object', 'choo.use: hooks should be an object') | |
| _store.use(hooks) | |
| } | |
| // create a new router with a custom `createRoute()` function | |
| // (str?, obj) -> null | |
| function createRouter (routerOpts, routes, createSend) { | |
| var prev = null | |
| if (!routes) { | |
| routes = routerOpts | |
| routerOpts = {} | |
| } | |
| routerOpts = mutate({ thunk: 'match' }, routerOpts) | |
| const router = sheetRouter(routerOpts, routes) | |
| walk(router, wrap) | |
| return router | |
| function wrap (route, handler) { | |
| const send = createSend('view: ' + route, true) | |
| return function chooWrap (params) { | |
| return function (state) { | |
| // TODO(yw): find a way to wrap handlers so params shows up in state | |
| const nwState = xtend(state) | |
| nwState.location = xtend(nwState.location, { params: params }) | |
| const nwPrev = prev | |
| prev = nwState // save for next time | |
| if (opts.freeze !== false) Object.freeze(nwState) | |
| return handler(nwState, nwPrev, send) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // application location model | |
| // obj -> obj | |
| function createLocationModel (opts) { | |
| return { | |
| namespace: 'location', | |
| state: mutate(createLocation(), { params: {} }), | |
| subscriptions: createSubscriptions(opts), | |
| effects: { set: setLocation, touch: touchLocation }, | |
| reducers: { update: updateLocation } | |
| } | |
| // update the location on the state | |
| // try and jump to an anchor on the page if it exists | |
| // (obj, obj) -> obj | |
| function updateLocation (state, data) { | |
| if (opts.history !== false && data.hash && data.hash !== state.hash) { | |
| try { | |
| const el = document.querySelector(data.hash) | |
| if (el) el.scrollIntoView(true) | |
| } catch (e) { | |
| return data | |
| } | |
| } | |
| return data | |
| } | |
| // update internal location only | |
| // (str, obj, fn, fn) -> null | |
| function touchLocation (state, data, send, done) { | |
| const newLocation = createLocation(state, data) | |
| send('location:update', newLocation, done) | |
| } | |
| // set a new location e.g. "/foo/bar#baz?beep=boop" | |
| // (str, obj, fn, fn) -> null | |
| function setLocation (state, data, send, done) { | |
| const newLocation = createLocation(state, data) | |
| // update url bar if it changed | |
| if (opts.history !== false && newLocation.href !== state.href) { | |
| window.history.pushState({}, null, newLocation.href) | |
| } | |
| send('location:update', newLocation, done) | |
| } | |
| function createSubscriptions (opts) { | |
| const subs = {} | |
| if (opts.history !== false) { | |
| subs.handleHistory = function (send, done) { | |
| onHistoryChange(function navigate (href) { | |
| send('location:touch', href, done) | |
| }) | |
| } | |
| } | |
| if (opts.href !== false) { | |
| subs.handleHref = function (send, done) { | |
| onHref(function navigate (location) { | |
| send('location:set', location, done) | |
| }) | |
| } | |
| } | |
| return subs | |
| } | |
| } | |
| },{"assert":1,"barracks":8,"nanoraf":12,"sheet-router":17,"sheet-router/create-location":14,"sheet-router/history":15,"sheet-router/href":16,"sheet-router/walk":22,"xtend":23,"xtend/mutable":24,"yo-yo":25}]},{},[]) | |
| //# sourceMappingURL=data:application/json;charset=utf-8;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/assert/assert.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-resolve/empty.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/process/browser.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/util/node_modules/inherits/inherits_browser.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/util/support/isBufferBrowser.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/util/util.js","node_modules/barracks/apply-hook.js","node_modules/barracks/index.js","node_modules/barracks/node_modules/nanotick/index.js","node_modules/global/document.js","node_modules/global/window.js","node_modules/nanoraf/index.js","node_modules/sheet-router/_pathname.js","node_modules/sheet-router/create-location.js","node_modules/sheet-router/history.js","node_modules/sheet-router/href.js","node_modules/sheet-router/index.js","node_modules/sheet-router/node_modules/wayfarer/index.js","node_modules/sheet-router/node_modules/wayfarer/trie.js","node_modules/sheet-router/node_modules/wayfarer/walk.js","node_modules/sheet-router/qs.js","node_modules/sheet-router/walk.js","node_modules/xtend/immutable.js","node_modules/xtend/mutable.js","node_modules/yo-yo/index.js","node_modules/yo-yo/node_modules/bel/index.js","node_modules/yo-yo/node_modules/bel/node_modules/hyperx/index.js","node_modules/yo-yo/node_modules/bel/node_modules/hyperx/node_modules/hyperscript-attribute-to-property/index.js","node_modules/yo-yo/node_modules/bel/node_modules/on-load/index.js","node_modules/yo-yo/node_modules/morphdom/dist/morphdom.js","node_modules/yo-yo/update-events.js","choo"],"names":[],"mappings":"AAAA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvWA;;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv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kBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;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;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjqBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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})","// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// when used in node, this will actually load the util module we depend on\n// versus loading the builtin util module as happens otherwise\n// this is a bug in node module loading as far as I am concerned\nvar util = require('util/');\n\nvar pSlice = Array.prototype.slice;\nvar hasOwn = Object.prototype.hasOwnProperty;\n\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  }\n  else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = stackStartFunction.name;\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction replacer(key, value) {\n  if (util.isUndefined(value)) {\n    return '' + value;\n  }\n  if (util.isNumber(value) && !isFinite(value)) {\n    return value.toString();\n  }\n  if (util.isFunction(value) || util.isRegExp(value)) {\n    return value.toString();\n  }\n  return value;\n}\n\nfunction truncate(s, n) {\n  if (util.isString(s)) {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\n\nfunction getMessage(self) {\n  return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(JSON.stringify(self.expected, replacer), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n\n  } else if (util.isBuffer(actual) && util.isBuffer(expected)) {\n    if (actual.length != expected.length) return false;\n\n    for (var i = 0; i < actual.length; i++) {\n      if (actual[i] !== expected[i]) return false;\n    }\n\n    return true;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if (!util.isObject(actual) && !util.isObject(expected)) {\n    return actual == expected;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else {\n    return objEquiv(actual, expected);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b) {\n  if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))\n    return false;\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b)) {\n    return a === b;\n  }\n  var aIsArgs = isArguments(a),\n      bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b);\n  }\n  var ka = objectKeys(a),\n      kb = objectKeys(b),\n      key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length != kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key])) return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  } else if (actual instanceof expected) {\n    return true;\n  } else if (expected.call({}, actual) === true) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (util.isString(expected)) {\n    message = expected;\n    expected = null;\n  }\n\n  try {\n    block();\n  } catch (e) {\n    actual = e;\n  }\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  if (!shouldThrow && expectedException(actual, expected)) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws.apply(this, [true].concat(pSlice.call(arguments)));\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/message) {\n  _throws.apply(this, [false].concat(pSlice.call(arguments)));\n};\n\nassert.ifError = function(err) { if (err) {throw err;}};\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n","module.exports = applyHook\n\n// apply arguments onto an array of functions, useful for hooks\n// (arr, any?, any?, any?, any?, any?) -> null\nfunction applyHook (arr, arg1, arg2, arg3, arg4, arg5) {\n  arr.forEach(function (fn) {\n    fn(arg1, arg2, arg3, arg4, arg5)\n  })\n}\n","var mutate = require('xtend/mutable')\nvar nanotick = require('nanotick')\nvar assert = require('assert')\nvar xtend = require('xtend')\n\nvar applyHook = require('./apply-hook')\n\nmodule.exports = dispatcher\n\n// initialize a new barracks instance\n// obj -> obj\nfunction dispatcher (hooks) {\n  hooks = hooks || {}\n  assert.equal(typeof hooks, 'object', 'barracks: hooks should be undefined or an object')\n\n  var onStateChangeHooks = []\n  var onActionHooks = []\n  var onErrorHooks = []\n\n  var subscriptionWraps = []\n  var initialStateWraps = []\n  var reducerWraps = []\n  var effectWraps = []\n\n  use(hooks)\n\n  var reducersCalled = false\n  var effectsCalled = false\n  var stateCalled = false\n  var subsCalled = false\n  var stopped = false\n\n  var subscriptions = start._subscriptions = {}\n  var reducers = start._reducers = {}\n  var effects = start._effects = {}\n  var models = start._models = []\n  var _state = {}\n\n  var tick = nanotick()\n\n  start.model = setModel\n  start.state = getState\n  start.start = start\n  start.stop = stop\n  start.use = use\n\n  return start\n\n  // push an object of hooks onto an array\n  // obj -> null\n  function use (hooks) {\n    assert.equal(typeof hooks, 'object', 'barracks.use: hooks should be an object')\n    assert.ok(!hooks.onError || typeof hooks.onError === 'function', 'barracks.use: onError should be undefined or a function')\n    assert.ok(!hooks.onAction || typeof hooks.onAction === 'function', 'barracks.use: onAction should be undefined or a function')\n    assert.ok(!hooks.onStateChange || typeof hooks.onStateChange === 'function', 'barracks.use: onStateChange should be undefined or a function')\n\n    if (hooks.onStateChange) onStateChangeHooks.push(hooks.onStateChange)\n    if (hooks.onError) onErrorHooks.push(wrapOnError(hooks.onError))\n    if (hooks.onAction) onActionHooks.push(hooks.onAction)\n    if (hooks.wrapSubscriptions) subscriptionWraps.push(hooks.wrapSubscriptions)\n    if (hooks.wrapInitialState) initialStateWraps.push(hooks.wrapInitialState)\n    if (hooks.wrapReducers) reducerWraps.push(hooks.wrapReducers)\n    if (hooks.wrapEffects) effectWraps.push(hooks.wrapEffects)\n    if (hooks.models) hooks.models.forEach(setModel)\n  }\n\n  // push a model to be initiated\n  // obj -> null\n  function setModel (model) {\n    assert.equal(typeof model, 'object', 'barracks.store.model: model should be an object')\n    models.push(model)\n  }\n\n  // get the current state from the store\n  // obj? -> obj\n  function getState (opts) {\n    opts = opts || {}\n    assert.equal(typeof opts, 'object', 'barracks.store.state: opts should be an object')\n\n    var state = opts.state\n    if (!opts.state && opts.freeze === false) return xtend(_state)\n    else if (!opts.state) return Object.freeze(xtend(_state))\n    assert.equal(typeof state, 'object', 'barracks.store.state: state should be an object')\n\n    var namespaces = []\n    var newState = {}\n\n    // apply all fields from the model, and namespaced fields from the passed\n    // in state\n    models.forEach(function (model) {\n      var ns = model.namespace\n      namespaces.push(ns)\n      var modelState = model.state || {}\n      if (ns) {\n        newState[ns] = newState[ns] || {}\n        apply(ns, modelState, newState)\n        newState[ns] = xtend(newState[ns], state[ns])\n      } else {\n        mutate(newState, modelState)\n      }\n    })\n\n    // now apply all fields that weren't namespaced from the passed in state\n    Object.keys(state).forEach(function (key) {\n      if (namespaces.indexOf(key) !== -1) return\n      newState[key] = state[key]\n    })\n\n    var tmpState = xtend(_state, xtend(state, newState))\n    var wrappedState = wrapHook(tmpState, initialStateWraps)\n\n    return (opts.freeze === false)\n      ? wrappedState\n      : Object.freeze(wrappedState)\n  }\n\n  // initialize the store hooks, get the send() function\n  // obj? -> fn\n  function start (opts) {\n    opts = opts || {}\n    assert.equal(typeof opts, 'object', 'barracks.store.start: opts should be undefined or an object')\n\n    // register values from the models\n    models.forEach(function (model) {\n      var ns = model.namespace\n      if (!stateCalled && model.state && opts.state !== false) {\n        var modelState = model.state || {}\n        if (ns) {\n          _state[ns] = _state[ns] || {}\n          apply(ns, modelState, _state)\n        } else {\n          mutate(_state, modelState)\n        }\n      }\n      if (!reducersCalled && model.reducers && opts.reducers !== false) {\n        apply(ns, model.reducers, reducers, function (cb) {\n          return wrapHook(cb, reducerWraps)\n        })\n      }\n      if (!effectsCalled && model.effects && opts.effects !== false) {\n        apply(ns, model.effects, effects, function (cb) {\n          return wrapHook(cb, effectWraps)\n        })\n      }\n      if (!subsCalled && model.subscriptions && opts.subscriptions !== false) {\n        apply(ns, model.subscriptions, subscriptions, function (cb, key) {\n          var send = createSend('subscription: ' + (ns ? ns + ':' + key : key))\n          cb = wrapHook(cb, subscriptionWraps)\n          cb(send, function (err) {\n            applyHook(onErrorHooks, err, _state, createSend)\n          })\n          return cb\n        })\n      }\n    })\n\n    // the state wrap is special because we want to operate on the full\n    // state rather than indvidual chunks, so we apply it outside the loop\n    if (!stateCalled && opts.state !== false) {\n      _state = wrapHook(_state, initialStateWraps)\n      if (onStateChangeHooks.length) {\n        applyHook(onStateChangeHooks, _state, {}, {}, 'init', createSend)\n      }\n    }\n\n    if (!opts.noSubscriptions) subsCalled = true\n    if (!opts.noReducers) reducersCalled = true\n    if (!opts.noEffects) effectsCalled = true\n    if (!opts.noState) stateCalled = true\n\n    if (!onErrorHooks.length) onErrorHooks.push(wrapOnError(defaultOnError))\n\n    return createSend\n\n    // call an action from a view\n    // (str, bool?) -> (str, any?, fn?) -> null\n    function createSend (selfName, callOnError) {\n      assert.equal(typeof selfName, 'string', 'barracks.store.start.createSend: selfName should be a string')\n      assert.ok(!callOnError || typeof callOnError === 'boolean', 'barracks.store.start.send: callOnError should be undefined or a boolean')\n\n      return function send (name, data, cb) {\n        if (!cb && !callOnError) {\n          cb = data\n          data = null\n        }\n        data = (typeof data === 'undefined' ? null : data)\n\n        assert.equal(typeof name, 'string', 'barracks.store.start.send: name should be a string')\n        assert.ok(!cb || typeof cb === 'function', 'barracks.store.start.send: cb should be a function')\n\n        var done = callOnError ? onErrorCallback : cb\n        _send(name, data, selfName, done)\n\n        function onErrorCallback (err) {\n          err = err || null\n          if (err) {\n            applyHook(onErrorHooks, err, _state, function createSend (selfName) {\n              return function send (name, data) {\n                assert.equal(typeof name, 'string', 'barracks.store.start.send: name should be a string')\n                data = (typeof data === 'undefined' ? null : data)\n                _send(name, data, selfName, done)\n              }\n            })\n          }\n        }\n      }\n    }\n\n    // call an action\n    // (str, str, any, fn) -> null\n    function _send (name, data, caller, cb) {\n      if (stopped) return\n\n      assert.equal(typeof name, 'string', 'barracks._send: name should be a string')\n      assert.equal(typeof caller, 'string', 'barracks._send: caller should be a string')\n      assert.equal(typeof cb, 'function', 'barracks._send: cb should be a function')\n\n      ;(tick(function () {\n        var reducersCalled = false\n        var effectsCalled = false\n        var newState = xtend(_state)\n\n        if (onActionHooks.length) {\n          applyHook(onActionHooks, _state, data, name, caller, createSend)\n        }\n\n        // validate if a namespace exists. Namespaces are delimited by ':'.\n        var actionName = name\n        if (/:/.test(name)) {\n          var arr = name.split(':')\n          var ns = arr.shift()\n          actionName = arr.join(':')\n        }\n\n        var _reducers = ns ? reducers[ns] : reducers\n        if (_reducers && _reducers[actionName]) {\n          if (ns) {\n            var reducedState = _reducers[actionName](_state[ns], data)\n            newState[ns] = xtend(_state[ns], reducedState)\n          } else {\n            mutate(newState, reducers[actionName](_state, data))\n          }\n          reducersCalled = true\n          if (onStateChangeHooks.length) {\n            applyHook(onStateChangeHooks, newState, data, _state, actionName, createSend)\n          }\n          _state = newState\n          cb(null, newState)\n        }\n\n        var _effects = ns ? effects[ns] : effects\n        if (!reducersCalled && _effects && _effects[actionName]) {\n          var send = createSend('effect: ' + name)\n          if (ns) _effects[actionName](_state[ns], data, send, cb)\n          else _effects[actionName](_state, data, send, cb)\n          effectsCalled = true\n        }\n\n        if (!reducersCalled && !effectsCalled) {\n          throw new Error('Could not find action ' + actionName)\n        }\n      }))()\n    }\n  }\n\n  // stop an app, essentially turns\n  // all send() calls into no-ops.\n  // () -> null\n  function stop () {\n    stopped = true\n  }\n}\n\n// compose an object conditionally\n// optionally contains a namespace\n// which is used to nest properties.\n// (str, obj, obj, fn?) -> null\nfunction apply (ns, source, target, wrap) {\n  if (ns && !target[ns]) target[ns] = {}\n  Object.keys(source).forEach(function (key) {\n    var cb = wrap ? wrap(source[key], key) : source[key]\n    if (ns) target[ns][key] = cb\n    else target[key] = cb\n  })\n}\n\n// handle errors all the way at the top of the trace\n// err? -> null\nfunction defaultOnError (err) {\n  throw err\n}\n\nfunction wrapOnError (onError) {\n  return function onErrorWrap (err, state, createSend) {\n    if (err) onError(err, state, createSend)\n  }\n}\n\n// take a apply an array of transforms onto a value. The new value\n// must be returned synchronously from the transform\n// (any, [fn]) -> any\nfunction wrapHook (value, transforms) {\n  transforms.forEach(function (transform) {\n    value = transform(value)\n  })\n  return value\n}\n","/* eslint-disable no-eval */\nvar assert = require('assert')\n\nmodule.exports = nanotick\nvar delay = (typeof window !== 'undefined' && window.document)\n  ? (typeof setImmediate !== 'undefined')\n    ? setImmediate\n    : setTimeout\n  : eval('process.nextTick')\n\n// Process.nextTick() batching ulity\n// null -> fn(any) -> fn(any)\nfunction nanotick () {\n  var callbacks = []\n  var interval = false\n\n  return function tick (cb) {\n    assert.equal(typeof cb, 'function', 'nanotick.tick: cb should be a function')\n\n    var isAsync = false\n\n    executeAsync(function () {\n      isAsync = true\n    })\n\n    return function wrappedTick () {\n      var length = arguments.length\n      var args = []\n      for (var i = 0; i < length; i++) {\n        args.push[arguments[i]]\n      }\n\n      if (isAsync) {\n        cb.apply(cb, args)\n      } else {\n        executeAsync(function () {\n          cb.apply(cb, args)\n        })\n      }\n    }\n  }\n\n  function executeAsync (cb) {\n    callbacks.push(cb)\n\n    if (!interval) {\n      interval = true\n      delay(function () {\n        while (callbacks.length > 0) {\n          callbacks.shift()()\n        }\n        interval = false\n      })\n    }\n  }\n}\n","var 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","if (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","var window = require('global/window')\nvar assert = require('assert')\n\nmodule.exports = nanoraf\n\n// Only call RAF when needed\n// (fn, fn?) -> fn\nfunction nanoraf (render, raf) {\n  assert.equal(typeof render, 'function', 'nanoraf: render should be a function')\n  assert.ok(typeof raf === 'function' || typeof raf === 'undefined', 'nanoraf: raf should be a function or undefined')\n\n  if (!raf) raf = window.requestAnimationFrame\n\n  var inRenderingTransaction = false\n  var redrawScheduled = false\n  var currentState = null\n\n  // pass new state to be rendered\n  // (obj, obj?) -> null\n  return function frame (state, prev) {\n    assert.equal(typeof state, 'object', 'nanoraf: state should be an object')\n    assert.equal(typeof prev, 'object', 'nanoraf: prev should be an object')\n    assert.equal(inRenderingTransaction, false, 'nanoraf: infinite loop detected')\n\n    // request a redraw for next frame\n    if (currentState === null && !redrawScheduled) {\n      redrawScheduled = true\n\n      raf(function redraw () {\n        redrawScheduled = false\n        if (!currentState) return\n\n        inRenderingTransaction = true\n        render(currentState, prev)\n        inRenderingTransaction = false\n\n        currentState = null\n      })\n    }\n\n    // update data for redraw\n    currentState = state\n  }\n}\n","/* eslint-disable no-useless-escape */\nvar electron = '^(file:\\/\\/|\\/)(.*\\.html?\\/?)?'\nvar protocol = '^(http(s)?(:\\/\\/))?(www\\.)?'\nvar domain = '[a-zA-Z0-9-_\\.]+(:[0-9]{1,5})?(\\/{1})?'\nvar qs = '[\\?].*$'\n/* eslint-enable no-useless-escape */\n\nvar stripElectron = new RegExp(electron)\nvar prefix = new RegExp(protocol + domain)\nvar normalize = new RegExp('#')\nvar suffix = new RegExp(qs)\n\nmodule.exports = pathname\n\n// replace everything in a route but the pathname and hash\n// TODO(yw): ditch 'suffix' and allow qs routing\n// (str, bool) -> str\nfunction pathname (route, isElectron) {\n  if (isElectron) route = route.replace(stripElectron, '')\n  else route = route.replace(prefix, '')\n  return route.replace(suffix, '').replace(normalize, '/')\n}\n","var document = require('global/document')\nvar assert = require('assert')\nvar xtend = require('xtend')\n\nvar qs = require('./qs')\n\nmodule.exports = createLocation\n\n// takes an initial representation of the location state\n// and then synchronize a mutation across all fields\n//\n// scenarios:\n// - create a state object from document.location; we got no state yet\n// - create a new state object from a string we pass in; full override mode\n// - patch a state object with some value we pass in - lil patchy stuff\n//\n// (obj?, str?) -> obj\nfunction createLocation (state, patch) {\n  if (!state) {\n    return {\n      pathname: document.location.pathname,\n      search: (document.location.search) ? qs(document.location.search) : {},\n      hash: document.location.hash,\n      href: document.location.href\n    }\n  } else {\n    assert.equal(typeof state, 'object', 'sheet-router/create-location: state should be an object')\n    if (typeof patch === 'string') {\n      return parseUrl(patch)\n    } else {\n      assert.equal(typeof patch, 'object', 'sheet-router/create-location: patch should be an object')\n      return xtend(state, patch)\n    }\n  }\n\n  // parse a URL into a kv object inside the browser\n  // str -> obj\n  function parseUrl (url) {\n    var a = document.createElement('a')\n    a.href = url\n\n    return {\n      href: a.href,\n      pathname: a.pathname,\n      search: (a.search) ? qs(a.search) : {},\n      hash: a.hash\n    }\n  }\n}\n","var document = require('global/document')\nvar window = require('global/window')\nvar assert = require('assert')\n\nmodule.exports = history\n\n// listen to html5 pushstate events\n// and update router accordingly\n// fn(str) -> null\nfunction history (cb) {\n  assert.equal(typeof cb, 'function', 'sheet-router/history: cb must be a function')\n  window.onpopstate = function () {\n    cb({\n      pathname: document.location.pathname,\n      search: document.location.search,\n      href: document.location.href,\n      hash: document.location.hash\n    })\n  }\n}\n","var window = require('global/window')\nvar assert = require('assert')\n\nvar qs = require('./qs')\n\nmodule.exports = href\n\nvar noRoutingAttrName = 'data-no-routing'\n\n// handle a click if is anchor tag with an href\n// and url lives on the same domain. Replaces\n// trailing '#' so empty links work as expected.\n// (fn(str), obj?) -> undefined\nfunction href (cb, root) {\n  assert.equal(typeof cb, 'function', 'sheet-router/href: cb must be a function')\n\n  window.onclick = function (e) {\n    if ((e.button && e.button !== 0) || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return\n\n    var node = (function traverse (node) {\n      if (!node || node === root) return\n      if (node.localName !== 'a') return traverse(node.parentNode)\n      if (node.href === undefined) return traverse(node.parentNode)\n      if (window.location.host !== node.host) return traverse(node.parentNode)\n      return node\n    })(e.target)\n\n    if (!node) return\n\n    var isRoutingDisabled = node.hasAttribute(noRoutingAttrName)\n    if (isRoutingDisabled) return\n\n    e.preventDefault()\n    cb({\n      pathname: node.pathname,\n      search: (node.search) ? qs(node.search) : {},\n      href: node.href,\n      hash: node.hash\n    })\n  }\n}\n","var pathname = require('./_pathname')\nvar wayfarer = require('wayfarer')\nvar assert = require('assert')\n\nvar isLocalFile = (/file:\\/\\//.test(typeof window === 'object' &&\n  window.location && window.location.origin)) // electron support\n\nmodule.exports = sheetRouter\n\n// Fast, modular client router\n// fn(str, any[..]) -> fn(str, any[..])\nfunction sheetRouter (opts, tree) {\n  if (!tree) {\n    tree = opts\n    opts = {}\n  }\n\n  assert.equal(typeof opts, 'object', 'sheet-router: opts must be a object')\n  assert.ok(Array.isArray(tree), 'sheet-router: tree must be an array')\n\n  var dft = opts.default || '/404'\n  assert.equal(typeof dft, 'string', 'sheet-router: dft must be a string')\n\n  var router = wayfarer(dft)\n  var prevCallback = null\n  var prevRoute = null\n\n  match._router = router\n\n  // register tree in router\n  // tree[0] is a string, thus a route\n  // tree[0] is an array, thus not a route\n  // tree[1] is a function\n    // tree[2] is an array\n    // tree[2] is not an array\n  // tree[1] is an array\n  ;(function walk (tree, fullRoute) {\n    if (typeof tree[0] === 'string') {\n      var route = tree[0].replace(/^[#/]/, '')\n    } else {\n      var rootArr = tree[0]\n    }\n\n    var cb = (typeof tree[1] === 'function') ? tree[1] : null\n    var children = (Array.isArray(tree[1]))\n      ? tree[1]\n      : Array.isArray(tree[2]) ? tree[2] : null\n\n    if (rootArr) {\n      tree.forEach(function (node) {\n        walk(node, fullRoute)\n      })\n    }\n\n    if (cb) {\n      var innerRoute = route\n        ? fullRoute.concat(route).join('/')\n        : fullRoute.length ? fullRoute.join('/') : route\n\n      // if opts.thunk is false or only enabled for match, don't thunk\n      var handler = (opts.thunk === false || opts.thunk === 'match')\n        ? cb\n        : thunkify(cb)\n      router.on(innerRoute, handler)\n    }\n\n    if (Array.isArray(children)) {\n      walk(children, fullRoute.concat(route))\n    }\n  })(tree, [])\n\n  return match\n\n  // match a route on the router\n  //\n  // no thunking -> call route with all arguments\n  // thunking only for match -> call route with all arguments\n  // thunking and route is same -> call prev cb with new args\n  // thunking and route is diff -> create cb and call with new args\n  //\n  // (str, [any..]) -> any\n  function match (route, arg1, arg2, arg3, arg4, arg5) {\n    assert.equal(typeof route, 'string', 'sheet-router: route must be a string')\n\n    if (opts.thunk === false) {\n      return router(pathname(route, isLocalFile), arg1, arg2, arg3, arg4, arg5)\n    } else if (route === prevRoute) {\n      return prevCallback(arg1, arg2, arg3, arg4, arg5)\n    } else {\n      prevRoute = pathname(route, isLocalFile)\n      prevCallback = router(prevRoute)\n      return prevCallback(arg1, arg2, arg3, arg4, arg5)\n    }\n  }\n}\n\n// wrap a function in a function so it can be called at a later time\n// fn -> obj -> (any, any, any, any, any)\nfunction thunkify (cb) {\n  return function (params) {\n    return function (arg1, arg2, arg3, arg4, arg5) {\n      return cb(params, arg1, arg2, arg3, arg4, arg5)\n    }\n  }\n}\n","const assert = require('assert')\nconst trie = require('./trie')\n\nmodule.exports = Wayfarer\n\n// create a router\n// str -> obj\nfunction Wayfarer (dft) {\n  if (!(this instanceof Wayfarer)) return new Wayfarer(dft)\n\n  const _default = (dft || '').replace(/^\\//, '')\n  const _trie = trie()\n\n  emit._trie = _trie\n  emit.emit = emit\n  emit.on = on\n  emit._wayfarer = true\n\n  return emit\n\n  // define a route\n  // (str, fn) -> obj\n  function on (route, cb) {\n    assert.equal(typeof route, 'string')\n    assert.equal(typeof cb, 'function')\n\n    route = route || '/'\n\n    if (cb && cb._wayfarer && cb._trie) {\n      _trie.mount(route, cb._trie.trie)\n    } else {\n      const node = _trie.create(route)\n      node.cb = cb\n    }\n\n    return emit\n  }\n\n  // match and call a route\n  // (str, obj?) -> null\n  function emit (route) {\n    assert.notEqual(route, undefined, \"'route' must be defined\")\n    const args = new Array(arguments.length)\n    for (var i = 1; i < args.length; i++) {\n      args[i] = arguments[i]\n    }\n\n    const node = _trie.match(route)\n    if (node && node.cb) {\n      args[0] = node.params\n      return node.cb.apply(null, args)\n    }\n\n    const dft = _trie.match(_default)\n    if (dft && dft.cb) {\n      args[0] = dft.params\n      return dft.cb.apply(null, args)\n    }\n\n    throw new Error(\"route '\" + route + \"' did not match\")\n  }\n}\n","const mutate = require('xtend/mutable')\nconst assert = require('assert')\nconst xtend = require('xtend')\n\nmodule.exports = Trie\n\n// create a new trie\n// null -> obj\nfunction Trie () {\n  if (!(this instanceof Trie)) return new Trie()\n  this.trie = { nodes: {} }\n}\n\n// create a node on the trie at route\n// and return a node\n// str -> null\nTrie.prototype.create = function (route) {\n  assert.equal(typeof route, 'string', 'route should be a string')\n  // strip leading '/' and split routes\n  const routes = route.replace(/^\\//, '').split('/')\n  return (function createNode (index, trie, routes) {\n    const route = routes[index]\n\n    if (route === undefined) return trie\n\n    var node = null\n    if (/^:/.test(route)) {\n      // if node is a name match, set name and append to ':' node\n      if (!trie.nodes['$$']) {\n        node = { nodes: {} }\n        trie.nodes['$$'] = node\n      } else {\n        node = trie.nodes['$$']\n      }\n      trie.name = route.replace(/^:/, '')\n    } else if (!trie.nodes[route]) {\n      node = { nodes: {} }\n      trie.nodes[route] = node\n    } else {\n      node = trie.nodes[route]\n    }\n\n    // we must recurse deeper\n    return createNode(index + 1, node, routes)\n  })(0, this.trie, routes)\n}\n\n// match a route on the trie\n// and return the node\n// str -> obj\nTrie.prototype.match = function (route) {\n  assert.equal(typeof route, 'string', 'route should be a string')\n\n  const routes = route.replace(/^\\//, '').split('/')\n  const params = {}\n\n  var node = (function search (index, trie) {\n    // either there's no match, or we're done searching\n    if (trie === undefined) return undefined\n    const route = routes[index]\n    if (route === undefined) return trie\n\n    if (trie.nodes[route]) {\n      // match regular routes first\n      return search(index + 1, trie.nodes[route])\n    } else if (trie.name) {\n      // match named routes\n      params[trie.name] = decodeURIComponent(route)\n      return search(index + 1, trie.nodes['$$'])\n    } else {\n      // no matches found\n      return search(index + 1)\n    }\n  })(0, this.trie)\n\n  if (!node) return undefined\n  node = xtend(node)\n  node.params = params\n  return node\n}\n\n// mount a trie onto a node at route\n// (str, obj) -> null\nTrie.prototype.mount = function (route, trie) {\n  assert.equal(typeof route, 'string', 'route should be a string')\n  assert.equal(typeof trie, 'object', 'trie should be a object')\n\n  const split = route.replace(/^\\//, '').split('/')\n  var node = null\n  var key = null\n\n  if (split.length === 1) {\n    key = split[0]\n    node = this.create(key)\n  } else {\n    const headArr = split.splice(0, split.length - 1)\n    const head = headArr.join('/')\n    key = split[0]\n    node = this.create(head)\n  }\n\n  mutate(node.nodes, trie.nodes)\n  if (trie.name) node.name = trie.name\n\n  // delegate properties from '/' to the new node\n  // '/' cannot be reached once mounted\n  if (node.nodes['']) {\n    Object.keys(node.nodes['']).forEach(function (key) {\n      if (key === 'nodes') return\n      node[key] = node.nodes[''][key]\n    })\n    mutate(node.nodes, node.nodes[''].nodes)\n    delete node.nodes[''].nodes\n  }\n}\n","const assert = require('assert')\n\nmodule.exports = walk\n\n// walk a wayfarer trie\n// (obj, fn) -> null\nfunction walk (router, transform) {\n  assert.equal(typeof router, 'function', 'wayfarer.walk: router should be an function')\n  assert.equal(typeof transform, 'function', 'wayfarer.walk: transform should be a function')\n\n  const trie = router._trie\n  assert.equal(typeof trie, 'object', 'wayfarer.walk: trie should be an object')\n\n  // (str, obj) -> null\n  ;(function walk (route, trie) {\n    if (trie.cb) {\n      trie.cb = transform(route, trie.cb)\n    }\n\n    if (trie.nodes) {\n      const nodes = trie.nodes\n      Object.keys(nodes).forEach(function (key) {\n        const node = nodes[key]\n        const newRoute = (key === '$$')\n          ? route + '/:' + trie.name\n          : route + '/' + key\n        walk(newRoute, node)\n      })\n    }\n  })('', trie.trie)\n}\n","var window = require('global/window')\n\nvar decodeURIComponent = window.decodeURIComponent\nvar reg = new RegExp('([^?=&]+)(=([^&]*))?', 'g')\n\nmodule.exports = qs\n\n// decode a uri into a kv representation :: str -> obj\nfunction qs (uri) {\n  var obj = {}\n  uri.replace(/^.*\\?/, '').replace(reg, map)\n  return obj\n\n  function map (a0, a1, a2, a3) {\n    obj[decodeURIComponent(a1)] = decodeURIComponent(a3)\n  }\n}\n","const walk = require('wayfarer/walk')\nconst assert = require('assert')\n\nmodule.exports = walkSheetRouter\n\nfunction walkSheetRouter (router, cb) {\n  assert.equal(typeof router, 'function', 'sheet-router/walk: router should be a function')\n  assert.equal(typeof cb, 'function', 'sheet-router/walk: cb should be a function')\n\n  router = router._router\n  return walk(router, cb)\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend(target) {\n    for (var i = 1; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\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    var oldValue = f.value\n    var newValue = t.value\n    // copy values for form elements\n    if ((f.nodeName === 'INPUT' && f.type !== 'file') || f.nodeName === 'SELECT') {\n      if (!newValue) {\n        t.value = f.value\n      } else if (newValue !== oldValue) {\n        f.value = newValue\n      }\n    } else if (f.nodeName === 'TEXTAREA') {\n      if (t.getAttribute('value') === null) f.value = t.value\n    }\n  }\n}\n","var document = require('global/document')\nvar hyperx = require('hyperx')\nvar onload = require('on-load')\n\nvar SVGNS = 'http://www.w3.org/2000/svg'\nvar XLINKNS = 'http://www.w3.org/1999/xlink'\n\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 belOnload () {\n      load(el)\n    }, function belOnunload () {\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          if (p === 'xlink:href') {\n            el.setAttributeNS(XLINKNS, p, val)\n          } else if (/^xmlns($|:)/i.test(p)) {\n            // skip xmlns definitions\n          } else {\n            el.setAttributeNS(null, p, val)\n          }\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.default = module.exports\nmodule.exports.createElement = belCreateElement\n","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', '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\nvar range; // Create a range object for efficently rendering strings to elements.\nvar NS_XHTML = 'http://www.w3.org/1999/xhtml';\n\nvar doc = typeof document === 'undefined' ? undefined : document;\n\nvar testEl = doc ?\n    doc.body || doc.createElement('div') :\n    {};\n\n// Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32>\n// (IE7+ support) <=IE7 does not support el.hasAttribute(name)\nvar actualHasAttributeNS;\n\nif (testEl.hasAttributeNS) {\n    actualHasAttributeNS = function(el, namespaceURI, name) {\n        return el.hasAttributeNS(namespaceURI, name);\n    };\n} else if (testEl.hasAttribute) {\n    actualHasAttributeNS = function(el, namespaceURI, name) {\n        return el.hasAttribute(name);\n    };\n} else {\n    actualHasAttributeNS = function(el, namespaceURI, name) {\n        return el.getAttributeNode(namespaceURI, name) != null;\n    };\n}\n\nvar hasAttributeNS = actualHasAttributeNS;\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\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 * 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 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    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    // 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\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            // Needed for IE. Apparently IE sets the placeholder as the\n            // node value and vise versa. This ignores an empty update.\n            if (newValue === '' && fromEl.firstChild.nodeValue === fromEl.placeholder) {\n                return;\n            }\n\n            fromEl.firstChild.nodeValue = newValue;\n        }\n    },\n    SELECT: function(fromEl, toEl) {\n        if (!hasAttributeNS(toEl, null, 'multiple')) {\n            var selectedIndex = -1;\n            var i = 0;\n            var curChild = toEl.firstChild;\n            while(curChild) {\n                var nodeName = curChild.nodeName;\n                if (nodeName && nodeName.toUpperCase() === 'OPTION') {\n                    if (hasAttributeNS(curChild, null, 'selected')) {\n                        selectedIndex = i;\n                        break;\n                    }\n                    i++;\n                }\n                curChild = curChild.nextSibling;\n            }\n\n            fromEl.selectedIndex = i;\n        }\n    }\n};\n\nvar ELEMENT_NODE = 1;\nvar TEXT_NODE = 3;\nvar COMMENT_NODE = 8;\n\nfunction noop() {}\n\nfunction defaultGetNodeKey(node) {\n    return node.id;\n}\n\nfunction morphdomFactory(morphAttrs) {\n\n    return function 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                        fromNextSibling = curFromNodeChild.nextSibling;\n\n                        if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {\n                            curToNodeChild = toNextSibling;\n                            curFromNodeChild = fromNextSibling;\n                            continue outer;\n                        }\n\n                        curFromNodeKey = getNodeKey(curFromNodeChild);\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                                                fromNextSibling = curFromNodeChild.nextSibling;\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                                                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}\n\nvar morphdom = morphdomFactory(morphAttrs);\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","const createLocation = require('sheet-router/create-location')\nconst onHistoryChange = require('sheet-router/history')\nconst sheetRouter = require('sheet-router')\nconst onHref = require('sheet-router/href')\nconst walk = require('sheet-router/walk')\nconst mutate = require('xtend/mutable')\nconst barracks = require('barracks')\nconst nanoraf = require('nanoraf')\nconst assert = require('assert')\nconst xtend = require('xtend')\nconst yo = require('yo-yo')\n\nmodule.exports = choo\n\n// framework for creating sturdy web applications\n// null -> fn\nfunction choo (opts) {\n  opts = opts || {}\n\n  const _store = start._store = barracks()\n  var _router = start._router = null\n  var _routerOpts = null\n  var _rootNode = null\n  var _routes = null\n  var _frame = null\n\n  if (typeof window !== 'undefined') {\n    _store.use({ onStateChange: render })\n  }\n  _store.use(opts)\n\n  start.toString = toString\n  start.router = router\n  start.model = model\n  start.start = start\n  start.stop = _store.stop\n  start.use = use\n\n  return start\n\n  // render the application to a string\n  // (str, obj) -> str\n  function toString (route, serverState) {\n    serverState = serverState || {}\n    assert.equal(typeof route, 'string', 'choo.app.toString: route must be a string')\n    assert.equal(typeof serverState, 'object', 'choo.app.toString: serverState must be an object')\n    _store.start({ subscriptions: false, reducers: false, effects: false })\n\n    const state = _store.state({ state: serverState })\n    const router = createRouter(_routerOpts, _routes, createSend)\n    const tree = router(route, state)\n    return tree.outerHTML || tree.toString()\n\n    function createSend () {\n      return function send () {\n        assert.ok(false, 'choo: send() cannot be called from Node')\n      }\n    }\n  }\n\n  // start the application\n  // (str?, obj?) -> DOMNode\n  function start () {\n    _store.model(createLocationModel(opts))\n    const createSend = _store.start(opts)\n    _router = start._router = createRouter(_routerOpts, _routes, createSend)\n    const state = _store.state({state: {}})\n\n    const tree = _router(state.location.href, state)\n    assert.ok(tree, 'choo.start: the router should always return a valid DOM node')\n    assert.equal(typeof tree, 'object', 'choo.start: the router should always return a valid DOM node')\n    _rootNode = tree\n    tree.done = done\n\n    return tree\n\n    // allow a 'mount' function to return the new node\n    // html -> null\n    function done (newNode) {\n      _rootNode = newNode\n    }\n  }\n\n  // update the DOM after every state mutation\n  // (obj, obj, obj, str, fn) -> null\n  function render (state, data, prev, name, createSend) {\n    if (!_frame) {\n      _frame = nanoraf(function (state, prev) {\n        const newTree = _router(state.location.href, state, prev)\n        _rootNode = yo.update(_rootNode, newTree)\n      })\n    }\n    _frame(state, prev)\n  }\n\n  // register all routes on the router\n  // (str?, [fn|[fn]]) -> obj\n  function router (defaultRoute, routes) {\n    _routerOpts = defaultRoute\n    _routes = routes\n  }\n\n  // create a new model\n  // (str?, obj) -> null\n  function model (model) {\n    _store.model(model)\n  }\n\n  // register a plugin\n  // (obj) -> null\n  function use (hooks) {\n    assert.equal(typeof hooks, 'object', 'choo.use: hooks should be an object')\n    _store.use(hooks)\n  }\n\n  // create a new router with a custom `createRoute()` function\n  // (str?, obj) -> null\n  function createRouter (routerOpts, routes, createSend) {\n    var prev = null\n    if (!routes) {\n      routes = routerOpts\n      routerOpts = {}\n    }\n    routerOpts = mutate({ thunk: 'match' }, routerOpts)\n    const router = sheetRouter(routerOpts, routes)\n    walk(router, wrap)\n\n    return router\n\n    function wrap (route, handler) {\n      const send = createSend('view: ' + route, true)\n      return function chooWrap (params) {\n        return function (state) {\n          // TODO(yw): find a way to wrap handlers so params shows up in state\n          const nwState = xtend(state)\n          nwState.location = xtend(nwState.location, { params: params })\n\n          const nwPrev = prev\n          prev = nwState // save for next time\n\n          if (opts.freeze !== false) Object.freeze(nwState)\n          return handler(nwState, nwPrev, send)\n        }\n      }\n    }\n  }\n}\n\n// application location model\n// obj -> obj\nfunction createLocationModel (opts) {\n  return {\n    namespace: 'location',\n    state: mutate(createLocation(), { params: {} }),\n    subscriptions: createSubscriptions(opts),\n    effects: { set: setLocation, touch: touchLocation },\n    reducers: { update: updateLocation }\n  }\n\n  // update the location on the state\n  // try and jump to an anchor on the page if it exists\n  // (obj, obj) -> obj\n  function updateLocation (state, data) {\n    if (opts.history !== false && data.hash && data.hash !== state.hash) {\n      try {\n        const el = document.querySelector(data.hash)\n        if (el) el.scrollIntoView(true)\n      } catch (e) {\n        return data\n      }\n    }\n    return data\n  }\n\n  // update internal location only\n  // (str, obj, fn, fn) -> null\n  function touchLocation (state, data, send, done) {\n    const newLocation = createLocation(state, data)\n    send('location:update', newLocation, done)\n  }\n\n  // set a new location e.g. \"/foo/bar#baz?beep=boop\"\n  // (str, obj, fn, fn) -> null\n  function setLocation (state, data, send, done) {\n    const newLocation = createLocation(state, data)\n\n    // update url bar if it changed\n    if (opts.history !== false && newLocation.href !== state.href) {\n      window.history.pushState({}, null, newLocation.href)\n    }\n\n    send('location:update', newLocation, done)\n  }\n\n  function createSubscriptions (opts) {\n    const subs = {}\n\n    if (opts.history !== false) {\n      subs.handleHistory = function (send, done) {\n        onHistoryChange(function navigate (href) {\n          send('location:touch', href, done)\n        })\n      }\n    }\n\n    if (opts.href !== false) {\n      subs.handleHref = function (send, done) {\n        onHref(function navigate (location) {\n          send('location:set', location, done)\n        })\n      }\n    }\n\n    return subs\n  }\n}\n"]} | |
| var html = require('choo/html') | |
| var choo = require('choo') | |
| var app = choo() | |
| app.use(titleStore) | |
| app.route('/', mainView) | |
| app.mount('body') | |
| function mainView (state, emit) { | |
| return html` | |
| <div> | |
| <h1>Title: ${state.title}</h1> | |
| <input type="text" value="${state.title}" oninput=${update} /> | |
| </div> | |
| ` | |
| function update (e) { | |
| emit('update', e.target.value) | |
| } | |
| } | |
| function titleStore (state, emitter) { | |
| state.title = 'Not quite set yet' | |
| emitter.on('DOMContentLoaded', function () { | |
| emitter.on('update', function (newTitle) { | |
| state.title = newTitle | |
| emitter.emit('render') | |
| }) | |
| }) | |
| } | |
| ;}, 0) |
This file contains 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": { | |
| "choo": "4.1.0" | |
| } | |
| } |
This file contains 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 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