\n \n `\n}\n",
"var trailingNewlineRegex = /\\n[\\s]+$/\nvar leadingNewlineRegex = /^\\n[\\s]+/\nvar trailingSpaceRegex = /[\\s]+$/\nvar leadingSpaceRegex = /^[\\s]+/\nvar multiSpaceRegex = /[\\n\\s]+/g\n\nvar TEXT_TAGS = [\n 'a', 'abbr', 'b', 'bdi', 'bdo', 'br', 'cite', 'data', 'dfn', 'em', 'i',\n 'kbd', 'mark', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'amp', 'small', 'span',\n 'strong', 'sub', 'sup', 'time', 'u', 'var', 'wbr'\n]\n\nvar VERBATIM_TAGS = [\n 'code', 'pre', 'textarea'\n]\n\nmodule.exports = function appendChild (el, childs) {\n if (!Array.isArray(childs)) return\n\n var nodeName = el.nodeName.toLowerCase()\n\n var hadText = false\n var value, leader\n\n for (var i = 0, len = childs.length; i < len; i++) {\n var node = childs[i]\n if (Array.isArray(node)) {\n appendChild(el, node)\n continue\n }\n\n if (typeof node === 'number' ||\n typeof node === 'boolean' ||\n typeof node === 'function' ||\n node instanceof Date ||\n node instanceof RegExp) {\n node = node.toString()\n }\n\n var lastChild = el.childNodes[el.childNodes.length - 1]\n\n // Iterate over text nodes\n if (typeof node === 'string') {\n hadText = true\n\n // If we already had text, append to the existing text\n if (lastChild && lastChild.nodeName === '#text') {\n lastChild.nodeValue += node\n\n // We didn't have a text node yet, create one\n } else {\n node = document.createTextNode(node)\n el.appendChild(node)\n lastChild = node\n }\n\n // If this is the last of the child nodes, make sure we close it out\n // right\n if (i === len - 1) {\n hadText = false\n // Trim the child text nodes if the current node isn't a\n // node where whitespace matters.\n if (TEXT_TAGS.indexOf(nodeName) === -1 &&\n VERBATIM_TAGS.indexOf(nodeName) === -1) {\n value = lastChild.nodeValue\n .replace(leadingNewlineRegex, '')\n .replace(trailingSpaceRegex, '')\n .replace(trailingNewlineRegex, '')\n .replace(multiSpaceRegex, ' ')\n if (value === '') {\n el.removeChild(lastChild)\n } else {\n lastChild.nodeValue = value\n }\n } else if (VERBATIM_TAGS.indexOf(nodeName) === -1) {\n // The very first node in the list should not have leading\n // whitespace. Sibling text nodes should have whitespace if there\n // was any.\n leader = i === 0 ? '' : ' '\n value = lastChild.nodeValue\n .replace(leadingNewlineRegex, leader)\n .replace(leadingSpaceRegex, ' ')\n .replace(trailingSpaceRegex, '')\n .replace(trailingNewlineRegex, '')\n .replace(multiSpaceRegex, ' ')\n lastChild.nodeValue = value\n }\n }\n\n // Iterate over DOM nodes\n } else if (node && node.nodeType) {\n // If the last node was a text node, make sure it is properly closed out\n if (hadText) {\n hadText = false\n\n // Trim the child text nodes if the current node isn't a\n // text node or a code node\n if (TEXT_TAGS.indexOf(nodeName) === -1 &&\n VERBATIM_TAGS.indexOf(nodeName) === -1) {\n value = lastChild.nodeValue\n .replace(leadingNewlineRegex, '')\n .replace(trailingNewlineRegex, '')\n .replace(multiSpaceRegex, ' ')\n\n // Remove empty text nodes, append otherwise\n if (value === '') {\n el.removeChild(lastChild)\n } else {\n lastChild.nodeValue = value\n }\n // Trim the child nodes if the current node is not a node\n // where all whitespace must be preserved\n } else if (VERBATIM_TAGS.indexOf(nodeName) === -1) {\n value = lastChild.nodeValue\n .replace(leadingSpaceRegex, ' ')\n .replace(leadingNewlineRegex, '')\n .replace(trailingNewlineRegex, '')\n .replace(multiSpaceRegex, ' ')\n lastChild.nodeValue = value\n }\n }\n\n // Store the last nodename\n var _nodeName = node.nodeName\n if (_nodeName) nodeName = _nodeName.toLowerCase()\n\n // Append the node to the DOM\n el.appendChild(node)\n }\n }\n}\n",
"var _$empty_3 = {};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=",
"var topLevel = typeof global !== 'undefined' ? global :\n typeof window !== 'undefined' ? window : {}\nvar minDoc = require('min-document');\n\nvar doccy;\n\nif (typeof document !== 'undefined') {\n doccy = document;\n} else {\n doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];\n\n if (!doccy) {\n doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;\n }\n}\n\nmodule.exports = doccy;\n",
"var win;\n\nif (typeof window !== \"undefined\") {\n win = window;\n} else if (typeof global !== \"undefined\") {\n win = global;\n} else if (typeof self !== \"undefined\"){\n win = self;\n} else {\n win = {};\n}\n\nmodule.exports = win;\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, function (index, el) {\n if (!document.documentElement.contains(el)) turnoff(index, el)\n })\n eachMutation(mutations[i].addedNodes, function (index, el) {\n if (document.documentElement.contains(el)) turnon(index, el)\n })\n }\n })\n\n observer.observe(document.documentElement, {\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\nmodule.exports.KEY_ATTR = KEY_ATTR\nmodule.exports.KEY_ID = KEY_ID\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] && nodes[i].childNodes.length > 0) {\n eachMutation(nodes[i].childNodes, fn)\n }\n }\n}\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 'onmouseenter',\n 'onmouseleave',\n 'ontouchcancel',\n 'ontouchend',\n 'ontouchmove',\n 'ontouchstart',\n 'ondragstart',\n 'ondrag',\n 'ondragenter',\n 'ondragleave',\n 'ondragover',\n 'ondrop',\n 'ondragend',\n 'onkeydown',\n 'onkeypress',\n 'onkeyup',\n 'onunload',\n 'onabort',\n 'onerror',\n 'onresize',\n 'onscroll',\n 'onselect',\n 'onchange',\n 'onsubmit',\n 'onreset',\n 'onfocus',\n 'onblur',\n 'oninput',\n // other common events\n 'oncontextmenu',\n 'onfocusin',\n 'onfocusout'\n]\n",
"var events = require('./events')\nvar eventsLength = events.length\n\nvar ELEMENT_NODE = 1\nvar TEXT_NODE = 3\nvar COMMENT_NODE = 8\n\nmodule.exports = morph\n\n// diff elements and apply the resulting patch to the old node\n// (obj, obj) -> null\nfunction morph (newNode, oldNode) {\n var nodeType = newNode.nodeType\n var nodeName = newNode.nodeName\n\n if (nodeType === ELEMENT_NODE) {\n copyAttrs(newNode, oldNode)\n }\n\n if (nodeType === TEXT_NODE || nodeType === COMMENT_NODE) {\n if (oldNode.nodeValue !== newNode.nodeValue) {\n oldNode.nodeValue = newNode.nodeValue\n }\n }\n\n // Some DOM nodes are weird\n // https://github.com/patrick-steele-idem/morphdom/blob/master/src/specialElHandlers.js\n if (nodeName === 'INPUT') updateInput(newNode, oldNode)\n else if (nodeName === 'OPTION') updateOption(newNode, oldNode)\n else if (nodeName === 'TEXTAREA') updateTextarea(newNode, oldNode)\n\n copyEvents(newNode, oldNode)\n}\n\nfunction copyAttrs (newNode, oldNode) {\n var oldAttrs = oldNode.attributes\n var newAttrs = newNode.attributes\n var attrNamespaceURI = null\n var attrValue = null\n var fromValue = null\n var attrName = null\n var attr = null\n\n for (var i = newAttrs.length - 1; i >= 0; --i) {\n attr = newAttrs[i]\n attrName = attr.name\n attrNamespaceURI = attr.namespaceURI\n attrValue = attr.value\n if (attrNamespaceURI) {\n attrName = attr.localName || attrName\n fromValue = oldNode.getAttributeNS(attrNamespaceURI, attrName)\n if (fromValue !== attrValue) {\n oldNode.setAttributeNS(attrNamespaceURI, attrName, attrValue)\n }\n } else {\n if (!oldNode.hasAttribute(attrName)) {\n oldNode.setAttribute(attrName, attrValue)\n } else {\n fromValue = oldNode.getAttribute(attrName)\n if (fromValue !== attrValue) {\n // apparently values are always cast to strings, ah well\n if (attrValue === 'null' || attrValue === 'undefined') {\n oldNode.removeAttribute(attrName)\n } else {\n oldNode.setAttribute(attrName, attrValue)\n }\n }\n }\n }\n }\n\n // Remove any extra attributes found on the original DOM element that\n // weren't found on the target element.\n for (var j = oldAttrs.length - 1; j >= 0; --j) {\n attr = oldAttrs[j]\n if (attr.specified !== false) {\n attrName = attr.name\n attrNamespaceURI = attr.namespaceURI\n\n if (attrNamespaceURI) {\n attrName = attr.localName || attrName\n if (!newNode.hasAttributeNS(attrNamespaceURI, attrName)) {\n oldNode.removeAttributeNS(attrNamespaceURI, attrName)\n }\n } else {\n if (!newNode.hasAttributeNS(null, attrName)) {\n oldNode.removeAttribute(attrName)\n }\n }\n }\n }\n}\n\nfunction copyEvents (newNode, oldNode) {\n for (var i = 0; i < eventsLength; i++) {\n var ev = events[i]\n if (newNode[ev]) { // if new element has a whitelisted attribute\n oldNode[ev] = newNode[ev] // update existing element\n } else if (oldNode[ev]) { // if existing element has it and new one doesnt\n oldNode[ev] = undefined // remove it from existing element\n }\n }\n}\n\nfunction updateOption (newNode, oldNode) {\n updateAttribute(newNode, oldNode, 'selected')\n}\n\n// The \"value\" attribute is special for the element since it sets the\n// initial value. Changing the \"value\" attribute without changing the \"value\"\n// property will have no effect since it is only used to the set the initial\n// value. Similar for the \"checked\" attribute, and \"disabled\".\nfunction updateInput (newNode, oldNode) {\n var newValue = newNode.value\n var oldValue = oldNode.value\n\n updateAttribute(newNode, oldNode, 'checked')\n updateAttribute(newNode, oldNode, 'disabled')\n\n if (newValue !== oldValue) {\n oldNode.setAttribute('value', newValue)\n oldNode.value = newValue\n }\n\n if (newValue === 'null') {\n oldNode.value = ''\n oldNode.removeAttribute('value')\n }\n\n if (!newNode.hasAttributeNS(null, 'value')) {\n oldNode.removeAttribute('value')\n } else if (oldNode.type === 'range') {\n // this is so elements like slider move their UI thingy\n oldNode.value = newValue\n }\n}\n\nfunction updateTextarea (newNode, oldNode) {\n var newValue = newNode.value\n if (newValue !== oldNode.value) {\n oldNode.value = newValue\n }\n\n if (oldNode.firstChild && oldNode.firstChild.nodeValue !== newValue) {\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 === '' && oldNode.firstChild.nodeValue === oldNode.placeholder) {\n return\n }\n\n oldNode.firstChild.nodeValue = newValue\n }\n}\n\nfunction updateAttribute (newNode, oldNode, name) {\n if (newNode[name] !== oldNode[name]) {\n oldNode[name] = newNode[name]\n if (newNode[name]) {\n oldNode.setAttribute(name, '')\n } else {\n oldNode.removeAttribute(name)\n }\n }\n}\n",
"var assert = require('assert')\nvar morph = require('./lib/morph')\n\nvar TEXT_NODE = 3\n// var DEBUG = false\n\nmodule.exports = nanomorph\n\n// Morph one tree into another tree\n//\n// no parent\n// -> same: diff and walk children\n// -> not same: replace and return\n// old node doesn't exist\n// -> insert new node\n// new node doesn't exist\n// -> delete old node\n// nodes are not the same\n// -> diff nodes and apply patch to old node\n// nodes are the same\n// -> walk all child nodes and append to old node\nfunction nanomorph (oldTree, newTree) {\n // if (DEBUG) {\n // console.log(\n // 'nanomorph\\nold\\n %s\\nnew\\n %s',\n // oldTree && oldTree.outerHTML,\n // newTree && newTree.outerHTML\n // )\n // }\n assert.equal(typeof oldTree, 'object', 'nanomorph: oldTree should be an object')\n assert.equal(typeof newTree, 'object', 'nanomorph: newTree should be an object')\n var tree = walk(newTree, oldTree)\n // if (DEBUG) console.log('=> morphed\\n %s', tree.outerHTML)\n return tree\n}\n\n// Walk and morph a dom tree\nfunction walk (newNode, oldNode) {\n // if (DEBUG) {\n // console.log(\n // 'walk\\nold\\n %s\\nnew\\n %s',\n // oldNode && oldNode.outerHTML,\n // newNode && newNode.outerHTML\n // )\n // }\n if (!oldNode) {\n return newNode\n } else if (!newNode) {\n return null\n } else if (newNode.isSameNode && newNode.isSameNode(oldNode)) {\n return oldNode\n } else if (newNode.tagName !== oldNode.tagName) {\n return newNode\n } else {\n morph(newNode, oldNode)\n updateChildren(newNode, oldNode)\n return oldNode\n }\n}\n\n// Update the children of elements\n// (obj, obj) -> null\nfunction updateChildren (newNode, oldNode) {\n // if (DEBUG) {\n // console.log(\n // 'updateChildren\\nold\\n %s\\nnew\\n %s',\n // oldNode && oldNode.outerHTML,\n // newNode && newNode.outerHTML\n // )\n // }\n var oldChild, newChild, morphed, oldMatch\n\n // The offset is only ever increased, and used for [i - offset] in the loop\n var offset = 0\n\n for (var i = 0; ; i++) {\n oldChild = oldNode.childNodes[i]\n newChild = newNode.childNodes[i - offset]\n // if (DEBUG) {\n // console.log(\n // '===\\n- old\\n %s\\n- new\\n %s',\n // oldChild && oldChild.outerHTML,\n // newChild && newChild.outerHTML\n // )\n // }\n // Both nodes are empty, do nothing\n if (!oldChild && !newChild) {\n break\n\n // There is no new child, remove old\n } else if (!newChild) {\n oldNode.removeChild(oldChild)\n i--\n\n // There is no old child, add new\n } else if (!oldChild) {\n oldNode.appendChild(newChild)\n offset++\n\n // Both nodes are the same, morph\n } else if (same(newChild, oldChild)) {\n morphed = walk(newChild, oldChild)\n if (morphed !== oldChild) {\n oldNode.replaceChild(morphed, oldChild)\n offset++\n }\n\n // Both nodes do not share an ID or a placeholder, try reorder\n } else {\n oldMatch = null\n\n // Try and find a similar node somewhere in the tree\n for (var j = i; j < oldNode.childNodes.length; j++) {\n if (same(oldNode.childNodes[j], newChild)) {\n oldMatch = oldNode.childNodes[j]\n break\n }\n }\n\n // If there was a node with the same ID or placeholder in the old list\n if (oldMatch) {\n morphed = walk(newChild, oldMatch)\n if (morphed !== oldMatch) offset++\n oldNode.insertBefore(morphed, oldChild)\n\n // It's safe to morph two nodes in-place if neither has an ID\n } else if (!newChild.id && !oldChild.id) {\n morphed = walk(newChild, oldChild)\n if (morphed !== oldChild) {\n oldNode.replaceChild(morphed, oldChild)\n offset++\n }\n\n // Insert the node at the index if we couldn't morph or find a matching node\n } else {\n oldNode.insertBefore(newChild, oldChild)\n offset++\n }\n }\n }\n}\n\nfunction same (a, b) {\n if (a.id) return a.id === b.id\n if (a.isSameNode) return a.isSameNode(b)\n if (a.tagName !== b.tagName) return false\n if (a.type === TEXT_NODE) return a.nodeValue === b.nodeValue\n return false\n}\n",
"'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar connectionStore = new WeakMap();\nvar ITERATION_KEY = Symbol('iteration key');\n\nfunction storeObservable(obj) {\n // this will be used to save (obj.key -> reaction) connections later\n connectionStore.set(obj, new Map());\n}\n\nfunction registerReactionForOperation(reaction, ref) {\n var target = ref.target;\n var key = ref.key;\n var type = ref.type;\n\n if (type === 'iterate') {\n key = ITERATION_KEY;\n }\n\n var reactionsForObj = connectionStore.get(target);\n var reactionsForKey = reactionsForObj.get(key);\n if (!reactionsForKey) {\n reactionsForKey = new Set();\n reactionsForObj.set(key, reactionsForKey);\n }\n // save the fact that the key is used by the reaction during its current run\n if (!reactionsForKey.has(reaction)) {\n reactionsForKey.add(reaction);\n reaction.cleaners.push(reactionsForKey);\n }\n}\n\nfunction getReactionsForOperation(ref) {\n var target = ref.target;\n var key = ref.key;\n var type = ref.type;\n\n var reactionsForTarget = connectionStore.get(target);\n var reactionsForKey = new Set();\n\n if (type === 'clear') {\n reactionsForTarget.forEach(function (_, key) {\n addReactionsForKey(reactionsForKey, reactionsForTarget, key);\n });\n } else {\n addReactionsForKey(reactionsForKey, reactionsForTarget, key);\n }\n\n if (type === 'add' || type === 'delete' || type === 'clear') {\n var iterationKey = Array.isArray(target) ? 'length' : ITERATION_KEY;\n addReactionsForKey(reactionsForKey, reactionsForTarget, iterationKey);\n }\n\n return reactionsForKey;\n}\n\nfunction addReactionsForKey(reactionsForKey, reactionsForTarget, key) {\n var reactions = reactionsForTarget.get(key);\n reactions && reactions.forEach(reactionsForKey.add, reactionsForKey);\n}\n\nfunction releaseReaction(reaction) {\n if (reaction.cleaners) {\n reaction.cleaners.forEach(releaseReactionKeyConnection, reaction);\n }\n reaction.cleaners = [];\n}\n\nfunction releaseReactionKeyConnection(reactionsForKey) {\n reactionsForKey.delete(this);\n}\n\n// reactions can call each other and form a call stack\nvar reactionStack = [];\nvar isDebugging = false;\n\nfunction runAsReaction(reaction, fn, context, args) {\n // do not build reactive relations, if the reaction is unobserved\n if (reaction.unobserved) {\n return Reflect.apply(fn, context, args);\n }\n\n // only run the reaction if it is not already in the reaction stack\n // TODO: improve this to allow explicitly recursive reactions\n if (reactionStack.indexOf(reaction) === -1) {\n // release the (obj -> key -> reactions) connections\n // and reset the cleaner connections\n releaseReaction(reaction);\n\n try {\n // set the reaction as the currently running one\n // this is required so that we can create (observable.prop -> reaction) pairs in the get trap\n reactionStack.push(reaction);\n return Reflect.apply(fn, context, args);\n } finally {\n // always remove the currently running flag from the reaction when it stops execution\n reactionStack.pop();\n }\n }\n}\n\n// register the currently running reaction to be queued again on obj.key mutations\nfunction registerRunningReactionForOperation(operation) {\n // get the current reaction from the top of the stack\n var runningReaction = reactionStack[reactionStack.length - 1];\n if (runningReaction) {\n debugOperation(runningReaction, operation);\n registerReactionForOperation(runningReaction, operation);\n }\n}\n\nfunction queueReactionsForOperation(operation) {\n // iterate and queue every reaction, which is triggered by obj.key mutation\n getReactionsForOperation(operation).forEach(queueReaction, operation);\n}\n\nfunction queueReaction(reaction) {\n debugOperation(reaction, this);\n // queue the reaction for later execution or run it immediately\n if (typeof reaction.scheduler === 'function') {\n reaction.scheduler(reaction);\n } else if (typeof reaction.scheduler === 'object') {\n reaction.scheduler.add(reaction);\n } else {\n reaction();\n }\n}\n\nfunction debugOperation(reaction, operation) {\n if (reaction.debugger && !isDebugging) {\n try {\n isDebugging = true;\n reaction.debugger(operation);\n } finally {\n isDebugging = false;\n }\n }\n}\n\nfunction hasRunningReaction() {\n return reactionStack.length > 0;\n}\n\nvar IS_REACTION = Symbol('is reaction');\n\nfunction observe(fn, options) {\n if ( options === void 0 ) options = {};\n\n // wrap the passed function in a reaction, if it is not already one\n var reaction = fn[IS_REACTION] ? fn : function reaction() {\n return runAsReaction(reaction, fn, this, arguments);\n };\n // save the scheduler and debugger on the reaction\n reaction.scheduler = options.scheduler;\n reaction.debugger = options.debugger;\n // save the fact that this is a reaction\n reaction[IS_REACTION] = true;\n // run the reaction once if it is not a lazy one\n if (!options.lazy) {\n reaction();\n }\n return reaction;\n}\n\nfunction unobserve(reaction) {\n // do nothing, if the reaction is already unobserved\n if (!reaction.unobserved) {\n // indicate that the reaction should not be triggered any more\n reaction.unobserved = true;\n // release (obj -> key -> reaction) connections\n releaseReaction(reaction);\n }\n // unschedule the reaction, if it is scheduled\n if (typeof reaction.scheduler === 'object') {\n reaction.scheduler.delete(reaction);\n }\n}\n\nvar proxyToRaw = new WeakMap();\nvar rawToProxy = new WeakMap();\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar instrumentations = {\n has: function has(key) {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, key: key, type: 'has' });\n return proto.has.apply(target, arguments);\n },\n get: function get(key) {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, key: key, type: 'get' });\n return proto.get.apply(target, arguments);\n },\n add: function add(key) {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n var hadKey = proto.has.call(target, key);\n // forward the operation before queueing reactions\n var result = proto.add.apply(target, arguments);\n if (!hadKey) {\n queueReactionsForOperation({ target: target, key: key, value: key, type: 'add' });\n }\n return result;\n },\n set: function set(key, value) {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n var hadKey = proto.has.call(target, key);\n var oldValue = proto.get.call(target, key);\n // forward the operation before queueing reactions\n var result = proto.set.apply(target, arguments);\n if (!hadKey) {\n queueReactionsForOperation({ target: target, key: key, value: value, type: 'add' });\n } else if (value !== oldValue) {\n queueReactionsForOperation({ target: target, key: key, value: value, oldValue: oldValue, type: 'set' });\n }\n return result;\n },\n delete: function delete$1(key) {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n var hadKey = proto.has.call(target, key);\n var oldValue = proto.get ? proto.get.call(target, key) : undefined;\n // forward the operation before queueing reactions\n var result = proto.delete.apply(target, arguments);\n if (hadKey) {\n queueReactionsForOperation({ target: target, key: key, oldValue: oldValue, type: 'delete' });\n }\n return result;\n },\n clear: function clear() {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n var hadItems = target.size !== 0;\n var oldTarget = target instanceof Map ? new Map(target) : new Set(target);\n // forward the operation before queueing reactions\n var result = proto.clear.apply(target, arguments);\n if (hadItems) {\n queueReactionsForOperation({ target: target, oldTarget: oldTarget, type: 'clear' });\n }\n return result;\n },\n forEach: function forEach() {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return proto.forEach.apply(target, arguments);\n },\n keys: function keys() {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return proto.keys.apply(target, arguments);\n },\n values: function values() {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return proto.values.apply(target, arguments);\n },\n entries: function entries() {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return proto.entries.apply(target, arguments);\n },\n get size() {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return Reflect.get(proto, 'size', target);\n }\n};\ninstrumentations[Symbol.iterator] = function () {\n var target = proxyToRaw.get(this);\n var proto = Reflect.getPrototypeOf(this);\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return proto[Symbol.iterator].apply(target, arguments);\n };\n\nvar collectionHandlers = {\n get: function get(target, key, receiver) {\n // instrument methods and property accessors to be reactive\n target = hasOwnProperty.call(instrumentations, key) ? instrumentations : target;\n return Reflect.get(target, key, receiver);\n }\n};\n\n// eslint-disable-next-line\nvar globalObj = Function(\"return this\")();\n\n// built-in object can not be wrapped by Proxies\n// their methods expect the object instance as the 'this' instead of the Proxy wrapper\n// complex objects are wrapped with a Proxy of instrumented methods\n// which switch the proxy to the raw object and to add reactive wiring\nvar handlers = new Map([[Map, collectionHandlers], [Set, collectionHandlers], [WeakMap, collectionHandlers], [WeakSet, collectionHandlers], [Object, false], [Array, false], [Int8Array, false], [Uint8Array, false], [Uint8ClampedArray, false], [Int16Array, false], [Uint16Array, false], [Int32Array, false], [Uint32Array, false], [Float32Array, false], [Float64Array, false]]);\n\nfunction shouldInstrument(ref) {\n var constructor = ref.constructor;\n\n var isBuiltIn = typeof constructor === 'function' && constructor.name in globalObj && globalObj[constructor.name] === constructor;\n return !isBuiltIn || handlers.has(constructor);\n}\n\nfunction getHandlers(obj) {\n return handlers.get(obj.constructor);\n}\n\nvar hasOwnProperty$1 = Object.prototype.hasOwnProperty;\nvar wellKnownSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) { return Symbol[key]; }).filter(function (value) { return typeof value === 'symbol'; }));\n\n// intercept get operations on observables to know which reaction uses their properties\nfunction get(target, key, receiver) {\n var result = Reflect.get(target, key, receiver);\n // do not register (observable.prop -> reaction) pairs for well known symbols\n // these symbols are frequently retrieved in low level JavaScript under the hood\n if (typeof key === 'symbol' && wellKnownSymbols.has(key)) {\n return result;\n }\n // register and save (observable.prop -> runningReaction)\n registerRunningReactionForOperation({ target: target, key: key, receiver: receiver, type: 'get' });\n // if we are inside a reaction and observable.prop is an object wrap it in an observable too\n // this is needed to intercept property access on that object too (dynamic observable tree)\n var observableResult = rawToProxy.get(result);\n if (hasRunningReaction() && typeof result === 'object' && result !== null) {\n if (observableResult) {\n return observableResult;\n }\n // do not violate the none-configurable none-writable prop get handler invariant\n // fall back to none reactive mode in this case, instead of letting the Proxy throw a TypeError\n var descriptor = Reflect.getOwnPropertyDescriptor(target, key);\n if (!descriptor || !(descriptor.writable === false && descriptor.configurable === false)) {\n return observable(result);\n }\n }\n // otherwise return the observable wrapper if it is already created and cached or the raw object\n return observableResult || result;\n}\n\nfunction has(target, key) {\n var result = Reflect.has(target, key);\n // register and save (observable.prop -> runningReaction)\n registerRunningReactionForOperation({ target: target, key: key, type: 'has' });\n return result;\n}\n\nfunction ownKeys(target) {\n registerRunningReactionForOperation({ target: target, type: 'iterate' });\n return Reflect.ownKeys(target);\n}\n\n// intercept set operations on observables to know when to trigger reactions\nfunction set(target, key, value, receiver) {\n // make sure to do not pollute the raw object with observables\n if (typeof value === 'object' && value !== null) {\n value = proxyToRaw.get(value) || value;\n }\n // save if the object had a descriptor for this key\n var hadKey = hasOwnProperty$1.call(target, key);\n // save if the value changed because of this set operation\n var oldValue = target[key];\n // execute the set operation before running any reaction\n var result = Reflect.set(target, key, value, receiver);\n // do not queue reactions if the target of the operation is not the raw receiver\n // (possible because of prototypal inheritance)\n if (target !== proxyToRaw.get(receiver)) {\n return result;\n }\n // queue a reaction if it's a new property or its value changed\n if (!hadKey) {\n queueReactionsForOperation({ target: target, key: key, value: value, receiver: receiver, type: 'add' });\n } else if (value !== oldValue) {\n queueReactionsForOperation({\n target: target,\n key: key,\n value: value,\n oldValue: oldValue,\n receiver: receiver,\n type: 'set'\n });\n }\n return result;\n}\n\nfunction deleteProperty(target, key) {\n // save if the object had the key\n var hadKey = hasOwnProperty$1.call(target, key);\n var oldValue = target[key];\n // execute the delete operation before running any reaction\n var result = Reflect.deleteProperty(target, key);\n // only queue reactions for delete operations which resulted in an actual change\n if (hadKey) {\n queueReactionsForOperation({ target: target, key: key, oldValue: oldValue, type: 'delete' });\n }\n return result;\n}\n\nvar baseHandlers = { get: get, has: has, ownKeys: ownKeys, set: set, deleteProperty: deleteProperty };\n\nfunction observable(obj) {\n if ( obj === void 0 ) obj = {};\n\n // if it is already an observable or it should not be wrapped, return it\n if (proxyToRaw.has(obj) || !shouldInstrument(obj)) {\n return obj;\n }\n // if it already has a cached observable wrapper, return it\n // otherwise create a new observable\n return rawToProxy.get(obj) || createObservable(obj);\n}\n\nfunction createObservable(obj) {\n // if it is a complex built-in object or a normal object, wrap it\n var handlers = getHandlers(obj) || baseHandlers;\n var observable = new Proxy(obj, handlers);\n // save these to switch between the raw object and the wrapped object with ease later\n rawToProxy.set(obj, observable);\n proxyToRaw.set(observable, obj);\n // init basic data structures to save and cleanup later (observable.prop -> reaction) connections\n storeObservable(obj);\n return observable;\n}\n\nfunction isObservable(obj) {\n return proxyToRaw.has(obj);\n}\n\nfunction raw(obj) {\n return proxyToRaw.get(obj) || obj;\n}\n\nexports.observe = observe;\nexports.unobserve = unobserve;\nexports.observable = observable;\nexports.isObservable = isObservable;\nexports.raw = raw;\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 objectCreate = Object.create || objectCreatePolyfill\nvar objectKeys = Object.keys || objectKeysPolyfill\nvar bind = Function.prototype.bind || functionBindPolyfill\n\nfunction EventEmitter() {\n if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {\n this._events = objectCreate(null);\n this._eventsCount = 0;\n }\n\n this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nvar hasDefineProperty;\ntry {\n var o = {};\n if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });\n hasDefineProperty = o.x === 0;\n} catch (err) { hasDefineProperty = false }\nif (hasDefineProperty) {\n Object.defineProperty(EventEmitter, 'defaultMaxListeners', {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n // check whether the input is a positive number (whose value is zero or\n // greater and not a NaN).\n if (typeof arg !== 'number' || arg < 0 || arg !== arg)\n throw new TypeError('\"defaultMaxListeners\" must be a positive number');\n defaultMaxListeners = arg;\n }\n });\n} else {\n EventEmitter.defaultMaxListeners = defaultMaxListeners;\n}\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== 'number' || n < 0 || isNaN(n))\n throw new TypeError('\"n\" argument must be a positive number');\n this._maxListeners = n;\n return this;\n};\n\nfunction $getMaxListeners(that) {\n if (that._maxListeners === undefined)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return $getMaxListeners(this);\n};\n\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n if (isFn)\n handler.call(self);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self);\n }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n if (isFn)\n handler.call(self, arg1);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1);\n }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n if (isFn)\n handler.call(self, arg1, arg2);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1, arg2);\n }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n if (isFn)\n handler.call(self, arg1, arg2, arg3);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1, arg2, arg3);\n }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n if (isFn)\n handler.apply(self, args);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].apply(self, args);\n }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n var er, handler, len, args, i, events;\n var doError = (type === 'error');\n\n events = this._events;\n if (events)\n doError = (doError && events.error == null);\n else if (!doError)\n return false;\n\n // If there is no 'error' event listener then throw.\n if (doError) {\n if (arguments.length > 1)\n er = arguments[1];\n if (er instanceof Error) {\n throw er; // Unhandled 'error' event\n } else {\n // At least give some kind of context to the user\n var err = new Error('Unhandled \"error\" event. (' + er + ')');\n err.context = er;\n throw err;\n }\n return false;\n }\n\n handler = events[type];\n\n if (!handler)\n return false;\n\n var isFn = typeof handler === 'function';\n len = arguments.length;\n switch (len) {\n // fast cases\n case 1:\n emitNone(handler, isFn, this);\n break;\n case 2:\n emitOne(handler, isFn, this, arguments[1]);\n break;\n case 3:\n emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n break;\n case 4:\n emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n break;\n // slower\n default:\n args = new Array(len - 1);\n for (i = 1; i < len; i++)\n args[i - 1] = arguments[i];\n emitMany(handler, isFn, this, args);\n }\n\n return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n\n events = target._events;\n if (!events) {\n events = target._events = objectCreate(null);\n target._eventsCount = 0;\n } else {\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (events.newListener) {\n target.emit('newListener', type,\n listener.listener ? listener.listener : listener);\n\n // Re-assign `events` because a newListener handler could have caused the\n // this._events to be assigned to a new object\n events = target._events;\n }\n existing = events[type];\n }\n\n if (!existing) {\n // Optimize the case of one listener. Don't need the extra array object.\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === 'function') {\n // Adding the second element, need to change to array.\n existing = events[type] =\n prepend ? [listener, existing] : [existing, listener];\n } else {\n // If we've already got an array, just append.\n if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n }\n\n // Check for listener leak\n if (!existing.warned) {\n m = $getMaxListeners(target);\n if (m && m > 0 && existing.length > m) {\n existing.warned = true;\n var w = new Error('Possible EventEmitter memory leak detected. ' +\n existing.length + ' \"' + String(type) + '\" listeners ' +\n 'added. Use emitter.setMaxListeners() to ' +\n 'increase limit.');\n w.name = 'MaxListenersExceededWarning';\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n if (typeof console === 'object' && console.warn) {\n console.warn('%s: %s', w.name, w.message);\n }\n }\n }\n }\n\n return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n\nfunction onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n switch (arguments.length) {\n case 0:\n return this.listener.call(this.target);\n case 1:\n return this.listener.call(this.target, arguments[0]);\n case 2:\n return this.listener.call(this.target, arguments[0], arguments[1]);\n case 3:\n return this.listener.call(this.target, arguments[0], arguments[1],\n arguments[2]);\n default:\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; ++i)\n args[i] = arguments[i];\n this.listener.apply(this.target, args);\n }\n }\n}\n\nfunction _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n var wrapped = bind.call(onceWrapper, state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n this.on(type, _onceWrap(this, type, listener));\n return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n function prependOnceListener(type, listener) {\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n\n events = this._events;\n if (!events)\n return this;\n\n list = events[type];\n if (!list)\n return this;\n\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = objectCreate(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit('removeListener', type, list.listener || listener);\n }\n } else if (typeof list !== 'function') {\n position = -1;\n\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (position === 0)\n list.shift();\n else\n spliceOne(list, position);\n\n if (list.length === 1)\n events[type] = list[0];\n\n if (events.removeListener)\n this.emit('removeListener', type, originalListener || listener);\n }\n\n return this;\n };\n\nEventEmitter.prototype.removeAllListeners =\n function removeAllListeners(type) {\n var listeners, events, i;\n\n events = this._events;\n if (!events)\n return this;\n\n // not listening for removeListener, no need to emit\n if (!events.removeListener) {\n if (arguments.length === 0) {\n this._events = objectCreate(null);\n this._eventsCount = 0;\n } else if (events[type]) {\n if (--this._eventsCount === 0)\n this._events = objectCreate(null);\n else\n delete events[type];\n }\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n var keys = objectKeys(events);\n var key;\n for (i = 0; i < keys.length; ++i) {\n key = keys[i];\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = objectCreate(null);\n this._eventsCount = 0;\n return this;\n }\n\n listeners = events[type];\n\n if (typeof listeners === 'function') {\n this.removeListener(type, listeners);\n } else if (listeners) {\n // LIFO order\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n\n return this;\n };\n\nfunction _listeners(target, type, unwrap) {\n var events = target._events;\n\n if (!events)\n return [];\n\n var evlistener = events[type];\n if (!evlistener)\n return [];\n\n if (typeof evlistener === 'function')\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === 'function') {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n var events = this._events;\n\n if (events) {\n var evlistener = events[type];\n\n if (typeof evlistener === 'function') {\n return 1;\n } else if (evlistener) {\n return evlistener.length;\n }\n }\n\n return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n list[i] = list[k];\n list.pop();\n}\n\nfunction arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n}\n\nfunction unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n}\n\nfunction objectCreatePolyfill(proto) {\n var F = function() {};\n F.prototype = proto;\n return new F;\n}\nfunction objectKeysPolyfill(obj) {\n var keys = [];\n for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {\n keys.push(k);\n }\n return k;\n}\nfunction functionBindPolyfill(context) {\n var fn = this;\n return function () {\n return fn.apply(context, arguments);\n };\n}\n",
"const onload = require('on-load')\nconst morph = require('nanomorph')\nconst util = require('@nx-js/observer-util')\nconst events = require('events')\nconst { observable, observe, unobserve, isObservable } = util\nconst KEY_ATTR = 'data-' + onload.KEY_ID\nlet id = 1\n\nfunction morphable (view) {\n if (typeof view !== 'function') return observable(view)\n\n let self = this\n let cache = new WeakMap()\n let reactions = new WeakMap()\n let int = 1\n\n const fn = function () {\n let args = Array.from(arguments)\n let rawArgs = args.map(state => morphable.raw(state))\n let index = args[0]\n\n let element\n if (cache.has(index)) {\n element = cache.get(index)\n } else {\n element = view.apply(self, rawArgs)\n element.id = id++\n }\n\n return onload(element, function (el) {\n if (isObservable(index)) {\n if (reactions.has(index)) return\n cache.set(index, el)\n }\n\n let init = false\n let int = el.id\n let reaction = observe(() => {\n fn.emit('premorph', morphable.raw(self), el, ...rawArgs)\n let update = view.apply(self, args)\n update.id = update.id || int\n update.setAttribute(KEY_ATTR, (cache.get(index) || el).getAttribute(KEY_ATTR))\n morph(el, update)\n if (init) {\n fn.emit('morph', morphable.raw(self), el, ...rawArgs)\n } else {\n fn.emit('load', morphable.raw(self), el, ...rawArgs)\n init = true\n }\n })\n\n if (isObservable(index)) reactions.set(index, reaction)\n }, el => {\n if (!reactions.has(index)) return\n fn.emit('unload', morphable.raw(self), el, ...rawArgs)\n unobserve(reactions.get(index))\n reactions.delete(index)\n }, id)\n }\n events.call(fn)\n Object.assign(fn, events.prototype)\n return fn\n}\n\nObject.assign(morphable, util)\n\nmodule.exports = morphable\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, function (index, el) {\n if (!document.documentElement.contains(el)) turnoff(index, el)\n })\n eachMutation(mutations[i].addedNodes, function (index, el) {\n if (document.documentElement.contains(el)) turnon(index, el)\n })\n }\n })\n\n observer.observe(document.documentElement, {\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\nmodule.exports.KEY_ATTR = KEY_ATTR\nmodule.exports.KEY_ID = KEY_ID\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] && nodes[i].childNodes.length > 0) {\n eachMutation(nodes[i].childNodes, fn)\n }\n }\n}\n",
"'use strict';\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar onload = require('on-load');\nvar morph = require('nanomorph');\nvar util = require('@nx-js/observer-util');\nvar events = require('events');\nvar observable = util.observable,\n observe = util.observe,\n unobserve = util.unobserve;\n\nvar KEY_ATTR = 'data-' + onload.KEY_ID;\nvar i = 1;\n\nfunction morphable(view) {\n if (typeof view !== 'function') return observable(view);\n\n var id = i++;\n var reaction = void 0;\n var cached = void 0;\n var self = this;\n\n var fn = function fn() {\n var args = Array.from(arguments);\n var rawArgs = args.map(function (state) {\n return morphable.raw(state);\n });\n var element = cached || view.apply(self, rawArgs);\n element.id = element.id || id;\n\n return onload(element, function (el) {\n if (reaction) return;\n cached = el;\n\n fn.emit.apply(fn, ['load', morphable.raw(self), el].concat(_toConsumableArray(rawArgs)));\n reaction = observe(function () {\n fn.emit.apply(fn, ['morph', morphable.raw(self), el].concat(_toConsumableArray(rawArgs)));\n\n var update = view.apply(self, args);\n update.id = update.id || id;\n update.setAttribute(KEY_ATTR, cached.getAttribute(KEY_ATTR));\n\n morph(el, update);\n });\n }, function (el) {\n if (!reaction) return;\n\n fn.emit.apply(fn, ['unload', morphable.raw(self), el].concat(_toConsumableArray(rawArgs)));\n unobserve(reaction);\n reaction = null;\n }, id);\n };\n events.call(fn);\n Object.assign(fn, events.prototype);\n return fn;\n}\n\nObject.assign(morphable, util);\n\nmodule.exports = morphable;\n",
"'use strict';\n\nvar _ = require('morphable');\n\nmodule.exports = xoo;\n\nfunction xoo() {\n var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n if (typeof obj === 'function') return _(obj);\n\n var use = [];\n var state = strictBind(_(obj));\n var observe = function observe() {\n return _.apply(state, arguments);\n };\n observe.use = function (fn) {\n var init = Object.assign({}, obj);\n use.push(fn);\n state = use.reduce(function (prev, next) {\n return next(prev) || prev;\n }, init);\n };\n\n observe.observable = function (obj) {\n return strictBind(_(obj));\n };\n\n return observe;\n\n function strictBind(obj) {\n // todo: decouple state mutation restrictions from binding actions to `this`\n var running = new Set();\n return new Proxy(obj, {\n get: function get(target, key, receiver) {\n if (typeof target[key] === 'function' && obj.hasOwnProperty(key)) {\n return function () {\n running.add(target[key]);\n var result = target[key].apply(state, arguments);\n running.delete(target[key]);\n return result;\n };\n }\n return target[key];\n },\n set: function set(target, key, val, receiver) {\n if (running.size === 0) throw new Error('Cannot mutate state outside of an action');else if (obj[key] === undefined) console.warn('Adding new observable property ' + key + ' dynamically in unsupported by proxy-polyfill');\n target[key] = val;\n return true;\n }\n });\n }\n}\n",
"const html = require('nanohtml')\nconst xoo = require('xoo')\nconst css = require('sheetify')\ncss('tachyons')\n\nconst bind = xoo({\n location: window.location.pathname,\n get route () {\n switch (this.location) {\n case '/':\n case '/index.html':\n return require('./main')\n default:\n return require('./404')\n }\n }\n})\n\nmodule.exports = bind(view)\n\nfunction view (state) {\n return html`\n \n ${this.route(state)}\n \n `\n}\n",
"const _ = require('morphable')\n\n// global state\n\nconst state = _({\n title: 'starter'\n})\n\n_.observe(() => document.title = state.title)\n\ndocument.body = require('./views')(state)\n"
],
"sourceRoot": ""
}
![\"digital](\"/assets/logo.svg\")
\n hello@starter.org\n