made with requirebin
Created
July 23, 2017 03:24
-
-
Save BinaryMuse/270f137a6ecc28aaf0832337b7036b57 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| const etch = require('etch') | |
| function toHTMLElement(vdom) { | |
| const component = { | |
| update() { /* noop */ }, | |
| render () { return vdom } | |
| } | |
| etch.initialize(component) | |
| return component.element | |
| } | |
| const domElement = toHTMLElement(etch.dom.div(null, etch.dom.span(null, 'Hello!'))) | |
| document.body.appendChild(domElement) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| setTimeout(function(){ | |
| ;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| const render = require('./render') | |
| const patch = require('./patch') | |
| const {getScheduler} = require('./scheduler-assignment') | |
| const componentsWithPendingUpdates = new WeakSet() | |
| let syncUpdatesInProgressCounter = 0 | |
| let syncDestructionsInProgressCounter = 0 | |
| function isValidVirtualNode (virtualNode) { | |
| return virtualNode != null && virtualNode !== false | |
| } | |
| // This function associates a component object with a DOM element by calling | |
| // the components `render` method, assigning an `.element` property on the | |
| // object and also returning the element. | |
| // | |
| // It also assigns a `virtualNode` property based on the return value of the | |
| // `render` method. This will be used later by `performElementUpdate` to diff | |
| // the new results of `render` with the previous results when updating the | |
| // component's element. | |
| // | |
| // Finally, this function also associates the component with a `refs` object, | |
| // which is populated with references to elements based on `ref` properties on | |
| // nodes of the `virtual-dom` tree. Before calling into `virtual-dom` to create | |
| // the DOM tree, it pushes this `refs` object to a shared stack so it can be | |
| // accessed by hooks during the creation of individual elements. | |
| function initialize(component) { | |
| if (typeof component.update !== 'function') { | |
| throw new Error('Etch components must implement `update(props, children)`.') | |
| } | |
| let virtualNode = component.render() | |
| if (!isValidVirtualNode(virtualNode)) { | |
| let namePart = component.constructor && component.constructor.name ? ' in ' + component.constructor.name : '' | |
| throw new Error('invalid falsy value ' + virtualNode + ' returned from render()' + namePart) | |
| } | |
| component.refs = {} | |
| component.virtualNode = virtualNode | |
| component.element = render(component.virtualNode, { | |
| refs: component.refs, listenerContext: component | |
| }) | |
| } | |
| // This function receives a component that has already been associated with an | |
| // element via a previous call to `initialize` and updates this element by | |
| // calling `render` on the component. | |
| // | |
| // When called in normal circumstances, it uses the scheduler to defer this | |
| // update until the next animation frame, and will only perform one update of a | |
| // given component in a given frame. This means you can call `update` | |
| // repeatedly in a given tick without causing redundant updates. | |
| // | |
| // If this function called during another synchronous update (for example, as a | |
| // result of a call to `update` on a child component), the update is performed | |
| // synchronously. | |
| // | |
| // Returns a promise that will resolve when the requested update has been | |
| // completed. | |
| function update (component, replaceNode=true) { | |
| if (syncUpdatesInProgressCounter > 0) { | |
| updateSync(component, replaceNode) | |
| return Promise.resolve() | |
| } | |
| let scheduler = getScheduler() | |
| if (!componentsWithPendingUpdates.has(component)) { | |
| componentsWithPendingUpdates.add(component) | |
| scheduler.updateDocument(function () { | |
| componentsWithPendingUpdates.delete(component) | |
| updateSync(component, replaceNode) | |
| }) | |
| } | |
| return scheduler.getNextUpdatePromise() | |
| } | |
| // Synchronsly updates the DOM element associated with a component object. . | |
| // This method assumes the presence of `.element` and `.virtualNode` | |
| // properties on the component, which are assigned in the `initialize` | |
| // function. | |
| // | |
| // It calls `render` on the component to obtain the desired state of the DOM, | |
| // then `diff`s it with the previous state and `patch`es the element based on | |
| // the resulting diff. During the patch operation, it pushes the component's | |
| // `refs` object to a shared stack so that references to DOM elements can be | |
| // updated. | |
| // | |
| // If `update` is called during the invocation of `updateSync`, | |
| // the requests are processed synchronously as well. We track whether this is | |
| // the case by incrementing and decrementing `syncUpdatesInProgressCounter` | |
| // around the call. | |
| // | |
| // For now, etch does not allow the root tag of the `render` method to change | |
| // between invocations, because we want to preserve a one-to-one relationship | |
| // between component objects and DOM elements for simplicity. | |
| function updateSync (component, replaceNode=true) { | |
| let newVirtualNode = component.render() | |
| if (!isValidVirtualNode(newVirtualNode)) { | |
| let namePart = component.constructor && component.constructor.name ? ' in ' + component.constructor.name : '' | |
| throw new Error('invalid falsy value ' + newVirtualNode + ' returned from render()' + namePart) | |
| } | |
| syncUpdatesInProgressCounter++ | |
| let oldVirtualNode = component.virtualNode | |
| let oldDomNode = component.element | |
| let newDomNode = patch(oldVirtualNode, newVirtualNode, { | |
| refs: component.refs, | |
| listenerContext: component | |
| }) | |
| component.virtualNode = newVirtualNode | |
| if (newDomNode !== oldDomNode && !replaceNode) { | |
| throw new Error('The root node type changed on update, but the update was performed with the replaceNode option set to false') | |
| } else { | |
| component.element = newDomNode | |
| } | |
| // We can safely perform additional writes after a DOM update synchronously, | |
| // but any reads need to be deferred until all writes are completed to avoid | |
| // DOM thrashing. Requested reads occur at the end of the the current frame | |
| // if this method was invoked via the scheduler. Otherwise, if `updateSync` | |
| // was invoked outside of the scheduler, the default scheduler will defer | |
| // reads until the next animation frame. | |
| if (typeof component.writeAfterUpdate === 'function') { | |
| component.writeAfterUpdate() | |
| } | |
| if (typeof component.readAfterUpdate === 'function') { | |
| getScheduler().readDocument(function () { | |
| component.readAfterUpdate() | |
| }) | |
| } | |
| syncUpdatesInProgressCounter-- | |
| } | |
| // Removes the component's associated element and calls `destroy` on any child | |
| // components. Normally, this function is asynchronous and will perform the | |
| // destruction on the next animation frame. If called as the result of another | |
| // update or destruction, it calls `destroy` on child components synchronously. | |
| // If called as the result of destroying a component higher in the DOM, the | |
| // element is not removed to avoid redundant DOM manipulation. Returns a promise | |
| // that resolves when the destruction is completed. | |
| function destroy (component, removeNode=true) { | |
| if (syncUpdatesInProgressCounter > 0 || syncDestructionsInProgressCounter > 0) { | |
| destroySync(component, removeNode) | |
| return Promise.resolve() | |
| } | |
| let scheduler = getScheduler() | |
| scheduler.updateDocument(function () { | |
| destroySync(component, removeNode) | |
| }) | |
| return scheduler.getNextUpdatePromise() | |
| } | |
| // A synchronous version of `destroy`. | |
| // | |
| // Note that we track whether `destroy` calls are in progress and only remove | |
| // the element if we are not a nested call. | |
| function destroySync (component, removeNode=true) { | |
| syncDestructionsInProgressCounter++ | |
| destroyChildComponents(component.virtualNode) | |
| if (syncDestructionsInProgressCounter === 1 && removeNode) component.element.remove() | |
| syncDestructionsInProgressCounter-- | |
| } | |
| function destroyChildComponents(virtualNode) { | |
| if (virtualNode.component && typeof virtualNode.component.destroy === 'function') { | |
| virtualNode.component.destroy() | |
| } else if (virtualNode.children) { | |
| virtualNode.children.forEach(destroyChildComponents) | |
| } | |
| } | |
| module.exports = { | |
| initialize, | |
| update, updateSync, | |
| destroy, destroySync | |
| } | |
| },{"./patch":5,"./render":6,"./scheduler-assignment":7}],2:[function(require,module,exports){ | |
| // If the scheduler is not customized via `etch.setScheduler`, an instance of | |
| // this class will be used to schedule updates to the document. The | |
| // `updateDocument` method accepts functions to be run at some point in the | |
| // future, then runs them on the next animation frame. | |
| module.exports = class DefaultScheduler { | |
| constructor () { | |
| this.updateRequests = [] | |
| this.readRequests = [] | |
| this.pendingAnimationFrame = null | |
| this.performUpdates = this.performUpdates.bind(this) | |
| this.performingUpdates = false | |
| } | |
| // Enqueues functions that write to the DOM to be performed on the next | |
| // animation frame. Functions passed to this method should *never* read from | |
| // the DOM, because that could cause synchronous reflows. | |
| updateDocument (fn) { | |
| this.updateRequests.push(fn) | |
| if (!this.pendingAnimationFrame) { | |
| this.pendingAnimationFrame = window.requestAnimationFrame(this.performUpdates) | |
| } | |
| } | |
| readDocument (fn) { | |
| this.readRequests.push(fn) | |
| if (!this.pendingAnimationFrame) { | |
| this.pendingAnimationFrame = window.requestAnimationFrame(this.performUpdates) | |
| } | |
| } | |
| // Returns a promise that will resolve at the end of the next update cycle, | |
| // after all the functions passed to `updateDocument` and `updateDocumentSync` | |
| // have been run. | |
| getNextUpdatePromise () { | |
| if (!this.nextUpdatePromise) { | |
| this.nextUpdatePromise = new Promise(resolve => { | |
| this.resolveNextUpdatePromise = resolve | |
| }) | |
| } | |
| return this.nextUpdatePromise | |
| } | |
| // Performs all the pending document updates. If running these update | |
| // functions causes *more* updates to be enqueued, they are run synchronously | |
| // in this update cycle without waiting for another frame. | |
| performUpdates () { | |
| while (this.updateRequests.length > 0) { | |
| this.updateRequests.shift()() | |
| } | |
| // We don't clear the pending frame until all update requests are processed. | |
| // This ensures updates requested within other updates are processed in the | |
| // current frame. | |
| this.pendingAnimationFrame = null | |
| // Now that updates are processed, we can perform all pending document reads | |
| // without the risk of interleaving them with writes and causing layout | |
| // thrashing. | |
| while (this.readRequests.length > 0) { | |
| this.readRequests.shift()() | |
| } | |
| if (this.nextUpdatePromise) { | |
| let resolveNextUpdatePromise = this.resolveNextUpdatePromise | |
| this.nextUpdatePromise = null | |
| this.resolveNextUpdatePromise = null | |
| resolveNextUpdatePromise() | |
| } | |
| } | |
| } | |
| },{}],3:[function(require,module,exports){ | |
| const EVENT_LISTENER_PROPS = require('./event-listener-props') | |
| const SVG_TAGS = require('./svg-tags') | |
| function dom (tag, props, ...children) { | |
| for (let i = 0; i < children.length;) { | |
| const child = children[i] | |
| switch (typeof child) { | |
| case 'string': | |
| case 'number': | |
| children[i] = {text: child} | |
| i++ | |
| break; | |
| case 'object': | |
| if (Array.isArray(child)) { | |
| children.splice(i, 1, ...child) | |
| } else if (!child) { | |
| children.splice(i, 1) | |
| } else { | |
| i++ | |
| } | |
| break; | |
| default: | |
| throw new Error(`Invalid child node: ${child}`) | |
| } | |
| } | |
| if (props) { | |
| for (const propName in props) { | |
| const eventName = EVENT_LISTENER_PROPS[propName] | |
| if (eventName) { | |
| if (!props.on) props.on = {} | |
| props.on[eventName] = props[propName] | |
| } | |
| } | |
| if (props.class) { | |
| props.className = props.class | |
| } | |
| } | |
| return {tag, props, children} | |
| } | |
| const HTML_TAGS = [ | |
| 'a', 'abbr', 'address', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', | |
| 'blockquote', 'body', 'button', 'canvas', 'caption', 'cite', 'code', | |
| 'colgroup', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', | |
| 'dt', 'em', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', | |
| 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'html', 'i', 'iframe', 'ins', 'kbd', | |
| 'label', 'legend', 'li', 'main', 'map', 'mark', 'menu', 'meter', 'nav', | |
| 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'pre', | |
| 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', | |
| 'select', 'small', 'span', 'strong', 'style', 'sub', 'summary', 'sup', | |
| 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', | |
| 'tr', 'u', 'ul', 'var', 'video', 'area', 'base', 'br', 'col', 'command', | |
| 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', | |
| 'track', 'wbr' | |
| ] | |
| for (const tagName of HTML_TAGS) { | |
| dom[tagName] = (props, ...children) => { | |
| return dom(tagName, props, ...children) | |
| } | |
| } | |
| for (const tagName of SVG_TAGS) { | |
| dom[tagName] = (props, ...children) => { | |
| return dom(tagName, props, ...children) | |
| } | |
| } | |
| module.exports = dom | |
| },{"./event-listener-props":4,"./svg-tags":9}],4:[function(require,module,exports){ | |
| module.exports = { | |
| onCopy: 'copy', | |
| onCut: 'cut', | |
| onPaste: 'paste', | |
| onCompositionEnd: 'compositionend', | |
| onCompositionStart: 'compositionstart', | |
| onCompositionUpdate: 'compositionupdate', | |
| onKeyDown: 'keydown', | |
| onKeyPress: 'keypress', | |
| onKeyUp: 'keyup', | |
| onFocus: 'focus', | |
| onBlur: 'blur', | |
| onChange: 'change', | |
| onInput: 'input', | |
| onSubmit: 'submit', | |
| onClick: 'click', | |
| onContextMenu: 'contextmenu', | |
| onDoubleClick: 'doubleclick', | |
| onDrag: 'drag', | |
| onDragEnd: 'dragend', | |
| onDragEnter: 'dragenter', | |
| onDragExit: 'dragexit', | |
| onDragLeave: 'dragleave', | |
| onDragOver: 'dragover', | |
| onDragStart: 'dragstart', | |
| onDrop: 'drop', | |
| onMouseDown: 'mousedown', | |
| onMouseEnter: 'mousenter', | |
| onMouseLeave: 'mouseleave', | |
| onMouseMove: 'mousemove', | |
| onMouseOut: 'mouseout', | |
| onMouseOver: 'mouseover', | |
| onMouseUp: 'mouseup', | |
| onSelect: 'select', | |
| onTouchCancel: 'touchcancel', | |
| onTouchEnd: 'touchend', | |
| onTouchMove: 'touchmove', | |
| onTouchStart: 'touchstart', | |
| onScroll: 'scroll', | |
| onWheel: 'wheel', | |
| onAbort: 'abort', | |
| onCanPlay: 'canplay', | |
| onCanPlayThrough: 'canplaythrough', | |
| onDurationChange: 'durationchange', | |
| onEmptied: 'emptied', | |
| onEncrypted: 'encrypted', | |
| onEnded: 'ended', | |
| onError: 'error', | |
| onLoadedData: 'loadeddata', | |
| onLoadedMetadata: 'loadedmetadat', | |
| onLoadStart: 'loadstart', | |
| onPause: 'pause', | |
| onPlay: 'play', | |
| onPlaying: 'playing', | |
| onProgress: 'progress', | |
| onRateChange: 'ratechange', | |
| onSeeked: 'seeked', | |
| onSeeking: 'seeking', | |
| onStalled: 'stalled', | |
| onSuspend: 'suspend', | |
| onTimeUpdate: 'timeupdate', | |
| onVolumeChange: 'volumechange', | |
| onWaiting: 'waiting', | |
| onLoad: 'load', | |
| onError: 'error', | |
| onAnimationStart: 'animationstart', | |
| onAnimationEnd: 'animationend', | |
| onAnimationIteration: 'animationiteration', | |
| onTransitionEnd: 'transitionend' | |
| } | |
| },{}],5:[function(require,module,exports){ | |
| const render = require('./render') | |
| const updateProps = require('./update-props') | |
| function patch (oldVirtualNode, newVirtualNode, options) { | |
| const oldNode = oldVirtualNode.domNode | |
| if (virtualNodesAreEqual(oldVirtualNode, newVirtualNode)) { | |
| let newNode | |
| if (newVirtualNode.text != null) { | |
| oldNode.nodeValue = newVirtualNode.text | |
| newNode = oldNode | |
| } else { | |
| if (typeof newVirtualNode.tag === 'function') { | |
| newNode = updateComponent(oldVirtualNode, newVirtualNode, options) | |
| } else { | |
| updateChildren(oldNode, oldVirtualNode.children, newVirtualNode.children, options) | |
| updateProps(oldNode, oldVirtualNode, newVirtualNode, options) | |
| newNode = oldNode | |
| } | |
| } | |
| newVirtualNode.domNode = newNode | |
| if (newNode !== oldNode && oldNode.parentNode) { | |
| oldNode.parentNode.replaceChild(newNode, oldNode) | |
| } | |
| return newNode | |
| } else { | |
| const parentNode = oldNode.parentNode | |
| const nextSibling = oldNode.nextSibling | |
| removeVirtualNode(oldVirtualNode, options && options.refs) | |
| const newNode = render(newVirtualNode, options) | |
| if (parentNode) parentNode.insertBefore(newNode, nextSibling) | |
| newVirtualNode.domNode = newNode | |
| return newNode | |
| } | |
| } | |
| function updateComponent (oldVirtualNode, newVirtualNode, options) { | |
| const {component, props: oldProps} = oldVirtualNode | |
| let {props: newProps, children: newChildren} = newVirtualNode | |
| newVirtualNode.component = component | |
| if (options && options.refs) { | |
| const refs = options.refs | |
| const oldRefName = oldProps && oldProps.ref | |
| const newRefName = newProps && newProps.ref | |
| if (newRefName !== oldRefName) { | |
| if (oldRefName && refs[oldRefName] === component) delete refs[oldRefName] | |
| if (newRefName) refs[newRefName] = component | |
| } | |
| } | |
| component.update(newProps || {}, newChildren) | |
| return component.element | |
| } | |
| function updateChildren (parentElement, oldChildren, newChildren, options) { | |
| let oldStartIndex = 0 | |
| let oldEndIndex = oldChildren.length - 1 | |
| let oldStartChild = oldChildren[0] | |
| let oldEndChild = oldChildren[oldEndIndex] | |
| let newStartIndex = 0 | |
| let newEndIndex = newChildren.length - 1 | |
| let newStartChild = newChildren[0] | |
| let newEndChild = newChildren[newEndIndex] | |
| let oldIndicesByKey | |
| while (oldStartIndex <= oldEndIndex && newStartIndex <= newEndIndex) { | |
| if (!oldStartChild) { | |
| oldStartChild = oldChildren[++oldStartIndex] | |
| } else if (!oldEndChild) { | |
| oldEndChild = oldChildren[--oldEndIndex] | |
| } else if (virtualNodesAreEqual(oldStartChild, newStartChild)) { | |
| patch(oldStartChild, newStartChild, options) | |
| oldStartChild = oldChildren[++oldStartIndex] | |
| newStartChild = newChildren[++newStartIndex] | |
| } else if (virtualNodesAreEqual(oldEndChild, newEndChild)) { | |
| patch(oldEndChild, newEndChild, options) | |
| oldEndChild = oldChildren[--oldEndIndex] | |
| newEndChild = newChildren[--newEndIndex] | |
| } else if (virtualNodesAreEqual(oldStartChild, newEndChild)) { | |
| patch(oldStartChild, newEndChild, options) | |
| parentElement.insertBefore(oldStartChild.domNode, oldEndChild.domNode.nextSibling) | |
| oldStartChild = oldChildren[++oldStartIndex] | |
| newEndChild = newChildren[--newEndIndex] | |
| } else if (virtualNodesAreEqual(oldEndChild, newStartChild)) { | |
| patch(oldEndChild, newStartChild, options) | |
| parentElement.insertBefore(oldEndChild.domNode, oldStartChild.domNode); | |
| oldEndChild = oldChildren[--oldEndIndex] | |
| newStartChild = newChildren[++newStartIndex] | |
| } else { | |
| if (!oldIndicesByKey) oldIndicesByKey = mapOldKeysToIndices(oldChildren, oldStartIndex, oldEndIndex) | |
| const key = getKey(newStartChild) | |
| const oldIndex = key ? oldIndicesByKey.get(key) : null | |
| if (oldIndex == null) { | |
| parentElement.insertBefore(render(newStartChild, options), oldStartChild.domNode) | |
| newStartChild = newChildren[++newStartIndex] | |
| } else { | |
| const oldChildToMove = oldChildren[oldIndex] | |
| patch(oldChildToMove, newStartChild, options) | |
| oldChildren[oldIndex] = undefined | |
| parentElement.insertBefore(oldChildToMove.domNode, oldStartChild.domNode) | |
| newStartChild = newChildren[++newStartIndex] | |
| } | |
| } | |
| } | |
| if (oldStartIndex > oldEndIndex) { | |
| const subsequentElement = newChildren[newEndIndex + 1] ? newChildren[newEndIndex + 1].domNode : null | |
| for (let i = newStartIndex; i <= newEndIndex; i++) { | |
| parentElement.insertBefore(render(newChildren[i], options), subsequentElement) | |
| } | |
| } else if (newStartIndex > newEndIndex) { | |
| for (let i = oldStartIndex; i <= oldEndIndex; i++) { | |
| const child = oldChildren[i] | |
| if (child) removeVirtualNode(child, options && options.refs) | |
| } | |
| } | |
| } | |
| function removeVirtualNode (virtualNode, refs, removeDOMNode = true) { | |
| const {domNode, props, children, component} = virtualNode | |
| const ref = props && props.ref | |
| if (component) { | |
| if (refs && ref && refs[ref] === component) delete refs[ref] | |
| if (typeof component.destroy === 'function') component.destroy() | |
| } else { | |
| if (refs && ref && refs[ref] === domNode) delete refs[ref] | |
| if (children) { | |
| for (let i = 0; i < children.length; i++) { | |
| removeVirtualNode(children[i], refs, false) | |
| } | |
| } | |
| } | |
| if (removeDOMNode) domNode.remove() | |
| } | |
| function virtualNodesAreEqual (oldVirtualNode, newVirtualNode) { | |
| return ( | |
| getKey(oldVirtualNode) === getKey(newVirtualNode) | |
| && oldVirtualNode.tag === newVirtualNode.tag | |
| ) | |
| } | |
| function getKey (virtualNode) { | |
| return virtualNode.props ? virtualNode.props.key : undefined | |
| } | |
| function mapOldKeysToIndices (children, startIndex, endIndex) { | |
| let oldIndicesByKey = new Map() | |
| for (let i = startIndex; i <= endIndex; i++) { | |
| const key = getKey(children[i]) | |
| if (key) oldIndicesByKey.set(key, i) | |
| } | |
| return oldIndicesByKey | |
| } | |
| module.exports = patch | |
| },{"./render":6,"./update-props":10}],6:[function(require,module,exports){ | |
| const updateProps = require('./update-props') | |
| const SVG_TAGS = require('./svg-tags') | |
| function render (virtualNode, options) { | |
| let domNode | |
| if (virtualNode.text != null) { | |
| domNode = document.createTextNode(virtualNode.text) | |
| } else { | |
| const {tag, children} = virtualNode | |
| let {props} = virtualNode | |
| if (typeof tag === 'function') { | |
| let ref | |
| if (props && props.ref) { | |
| ref = props.ref | |
| } | |
| const component = new tag(props || {}, children) | |
| virtualNode.component = component | |
| domNode = component.element | |
| if (options && options.refs && ref) { | |
| options.refs[ref] = component | |
| } | |
| } else if (SVG_TAGS.has(tag)) { | |
| domNode = document.createElementNS("http://www.w3.org/2000/svg", tag); | |
| if (children) addChildren(domNode, children, options) | |
| if (props) updateProps(domNode, null, virtualNode, options) | |
| } else { | |
| domNode = document.createElement(tag) | |
| if (children) addChildren(domNode, children, options) | |
| if (props) updateProps(domNode, null, virtualNode, options) | |
| } | |
| } | |
| virtualNode.domNode = domNode | |
| return domNode | |
| } | |
| function addChildren (parent, children, options) { | |
| for (let i = 0; i < children.length; i++) { | |
| parent.appendChild(render(children[i], options)) | |
| } | |
| } | |
| module.exports = render | |
| },{"./svg-tags":9,"./update-props":10}],7:[function(require,module,exports){ | |
| // This file implements getter and setter functions for a scheduler to be used | |
| // by this library when updating the DOM. The scheduler's job is to ensure that | |
| // DOM interaction is performed efficiently. When using `etch` in Atom, you | |
| // should tell `etch` to use Atom's scheduler by calling | |
| // `setScheduler(atom.views)`. | |
| // | |
| // Schedulers should support the following interface: | |
| // * `updateDocument(fn)` This method is asynchronous. It enqueues functions to | |
| // be executed later. | |
| // * `getNextUpdatePromise()` This function should return a promise that | |
| // resolves after all pending document update functions have been invoked. | |
| // | |
| // Schedulers could support the following optional methods, which are supported | |
| // by Atom's scheduler. | |
| // | |
| // * `readDocument` This method can be invoked by clients other than `etch` when | |
| // it is necessary to read from the DOM. Functions enqueued via this method | |
| // should not be run until all document update functions have been executed. | |
| // Batching updates and reads in this way will prevent forced synchronous | |
| // reflows. | |
| // * `pollDocument` This method is similar to `readDocument`, but it runs the | |
| // associated functions repeatedly. Again, they should be scheduled in such a | |
| // way so as to avoid synchronous reflows. | |
| const DefaultScheduler = require('./default-scheduler') | |
| let scheduler = null | |
| module.exports.setScheduler = function setScheduler (customScheduler) { | |
| scheduler = customScheduler | |
| } | |
| module.exports.getScheduler = function getScheduler () { | |
| if (!scheduler) { | |
| scheduler = new DefaultScheduler() | |
| } | |
| return scheduler | |
| } | |
| },{"./default-scheduler":2}],8:[function(require,module,exports){ | |
| // Based on https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute | |
| module.exports = new Map([ | |
| ['accentHeight', 'accent-height'], | |
| ['alignmentBaseline', 'alignment-baseline'], | |
| ['arabicForm', 'arabic-form'], | |
| ['baselineShift', 'baseline-shift'], | |
| ['capHeight', 'cap-height'], | |
| ['className', 'class'], | |
| ['clipPath', 'clip-path'], | |
| ['clipRule', 'clip-rule'], | |
| ['colorInterpolation', 'color-interpolation'], | |
| ['colorInterpolationFilters', 'color-interpolation-filters'], | |
| ['colorProfile', 'color-profile'], | |
| ['colorRendering', 'color-rendering'], | |
| ['dominantBaseline', 'dominant-baseline'], | |
| ['enableBackground', 'enable-background'], | |
| ['fillOpacity', 'fill-opacity'], | |
| ['fillRule', 'fill-rule'], | |
| ['floodColor', 'flood-color'], | |
| ['floodOpacity', 'flood-opacity'], | |
| ['fontFamily', 'font-family'], | |
| ['fontSize', 'font-size'], | |
| ['fontSizeAdjust', 'font-size-adjust'], | |
| ['fontStretch', 'font-stretch'], | |
| ['fontStyle', 'font-style'], | |
| ['fontVariant', 'font-variant'], | |
| ['fontWeight', 'font-weight'], | |
| ['glyphName', 'glyph-name'], | |
| ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'], | |
| ['glyphOrientationVertical', 'glyph-orientation-vertical'], | |
| ['horizAdvX', 'horiz-adv-x'], | |
| ['horizOriginX', 'horiz-origin-x'], | |
| ['letterSpacing', 'letter-spacing'], | |
| ['lightingColor', 'lighting-color'], | |
| ['markerEnd', 'marker-end'], | |
| ['markerMid', 'marker-mid'], | |
| ['markerStart', 'marker-start'], | |
| ['overlinePosition', 'overline-position'], | |
| ['overlineThickness', 'overline-thickness'], | |
| ['panose1', 'panose-1'], | |
| ['paintOrder', 'paint-order'], | |
| ['pointerEvents', 'pointer-events'], | |
| ['renderingIntent', 'rendering-intent'], | |
| ['shapeRendering', 'shape-rendering'], | |
| ['stopColor', 'stop-color'], | |
| ['stopOpacity', 'stop-opacity'], | |
| ['strikethroughPosition', 'strikethrough-position'], | |
| ['strikethroughThickness', 'strikethrough-thickness'], | |
| ['strokeDasharray', 'stroke-dasharray'], | |
| ['strokeDashoffset', 'stroke-dashoffset'], | |
| ['strokeLinecap', 'stroke-linecap'], | |
| ['strokeLinejoin', 'stroke-linejoin'], | |
| ['strokeMiterlimit', 'stroke-miterlimit'], | |
| ['strokeOpacity', 'stroke-opacity'], | |
| ['strokeWidth', 'stroke-width'], | |
| ['textAnchor', 'text-anchor'], | |
| ['textDecoration', 'text-decoration'], | |
| ['textRendering', 'text-rendering'], | |
| ['underlinePosition', 'underline-position'], | |
| ['underlineThickness', 'underline-thickness'], | |
| ['unicodeBidi', 'unicode-bidi'], | |
| ['unicodeRange', 'unicode-range'], | |
| ['unitsPerEm', 'units-per-em'], | |
| ['vAlphabetic', 'v-alphabetic'], | |
| ['vHanging', 'v-hanging'], | |
| ['vIdeographic', 'v-ideographic'], | |
| ['vMathematical', 'v-mathematical'], | |
| ['vertAdvY', 'vert-adv-y'], | |
| ['vertOriginX', 'vert-origin-x'], | |
| ['vertOriginY', 'vert-origin-y'], | |
| ['wordSpacing', 'word-spacing'], | |
| ['writingMode', 'writing-mode'], | |
| ['xHeight', 'x-height'], | |
| ]) | |
| },{}],9:[function(require,module,exports){ | |
| // taken from https://github.com/facebook/react/blob/67f8524e88abbf1ac0fd86d38a0477d11fbc7b3e/src/isomorphic/classic/element/ReactDOMFactories.js#L153 | |
| module.exports = new Set([ | |
| 'circle', | |
| 'clipPath', | |
| 'defs', | |
| 'ellipse', | |
| 'g', | |
| 'image', | |
| 'line', | |
| 'linearGradient', | |
| 'mask', | |
| 'path', | |
| 'pattern', | |
| 'polygon', | |
| 'polyline', | |
| 'radialGradient', | |
| 'rect', | |
| 'stop', | |
| 'svg', | |
| 'text', | |
| 'tspan' | |
| ]) | |
| },{}],10:[function(require,module,exports){ | |
| const EVENT_LISTENER_PROPS = require('./event-listener-props') | |
| const SVG_TAGS = require('./svg-tags') | |
| const SVG_ATTRIBUTE_TRANSLATIONS = require('./svg-attribute-translations') | |
| const EMPTY = '' | |
| module.exports = function (domNode, oldVirtualNode, newVirtualNode, options) { | |
| const oldProps = oldVirtualNode && oldVirtualNode.props | |
| const newProps = newVirtualNode.props | |
| let refs, listenerContext | |
| if (options) { | |
| refs = options.refs | |
| listenerContext = options.listenerContext | |
| } | |
| updateProps(domNode, oldVirtualNode, oldProps, newVirtualNode, newProps) | |
| if (refs) updateRef(domNode, oldProps && oldProps.ref, newProps && newProps.ref, refs) | |
| updateEventListeners(domNode, oldVirtualNode, newVirtualNode, listenerContext) | |
| } | |
| function updateProps (domNode, oldVirtualNode, oldProps, newVirtualNode, newProps) { | |
| if (oldProps) { | |
| const oldPropsNames = Object.keys(oldProps) | |
| for (let i = 0; i < oldPropsNames.length; i++) { | |
| const name = oldPropsNames[i] | |
| if (name === 'ref' || name === 'on') continue | |
| if (name in EVENT_LISTENER_PROPS) continue | |
| if (!newProps || !(name in newProps)) { | |
| if (name === 'dataset') { | |
| updateProps(domNode.dataset, null, oldProps && oldProps.dataset, null, null) | |
| } else if (name !== 'innerHTML' && oldVirtualNode && SVG_TAGS.has(oldVirtualNode.tag)) { | |
| domNode.removeAttribute(SVG_ATTRIBUTE_TRANSLATIONS.get(name) || name) | |
| } else { | |
| // Clear property for objects that don't support deletion (e.g. style | |
| // or className). If we used null instead of an empty string, the DOM | |
| // could sometimes stringify the value and mistakenly assign 'null'. | |
| domNode[name] = EMPTY | |
| delete domNode[name] | |
| } | |
| } | |
| } | |
| } | |
| if (newProps) { | |
| const newPropsNames = Object.keys(newProps) | |
| for (let i = 0; i < newPropsNames.length; i++) { | |
| const name = newPropsNames[i] | |
| if (name === 'ref' || name === 'on') continue | |
| if (name in EVENT_LISTENER_PROPS) continue | |
| const oldValue = oldProps && oldProps[name] | |
| const newValue = newProps[name] | |
| if (name === 'dataset') { | |
| updateNestedProps(domNode.dataset, oldValue, newValue, false) | |
| } else if (name === 'style' && typeof newValue !== 'string') { | |
| let oldProps = oldValue | |
| if (typeof oldProps === 'string') { | |
| domNode.style = '' | |
| oldProps = null | |
| } | |
| updateNestedProps(domNode.style, oldProps, newValue, true) | |
| } else if (name === 'attributes') { | |
| updateAttributes(domNode, oldValue, newValue) | |
| } else { | |
| if (newValue !== oldValue) { | |
| if (name !== 'innerHTML' && newVirtualNode && SVG_TAGS.has(newVirtualNode.tag)) { | |
| domNode.setAttribute(SVG_ATTRIBUTE_TRANSLATIONS.get(name) || name, newValue) | |
| } else { | |
| domNode[name] = newValue | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| function updateNestedProps (domProps, oldProps, newProps, isStyleObject) { | |
| if (oldProps) { | |
| const oldPropsNames = Object.keys(oldProps) | |
| for (let i = 0; i < oldPropsNames.length; i++) { | |
| const name = oldPropsNames[i] | |
| if (!newProps || !(name in newProps)) { | |
| if (isStyleObject) { | |
| domProps[name] = EMPTY | |
| } else { | |
| delete domProps[name] | |
| } | |
| } | |
| } | |
| } | |
| if (newProps) { | |
| const newPropsNames = Object.keys(newProps) | |
| for (let i = 0; i < newPropsNames.length; i++) { | |
| const name = newPropsNames[i] | |
| const oldValue = oldProps && oldProps[name] | |
| const newValue = newProps[name] | |
| if (newValue !== oldValue) { | |
| domProps[name] = newValue | |
| } | |
| } | |
| } | |
| } | |
| function updateAttributes (domNode, oldAttributes, newAttributes) { | |
| if (oldAttributes) { | |
| const oldAttributeNames = Object.keys(oldAttributes) | |
| for (let i = 0; i < oldAttributeNames.length; i++) { | |
| const name = oldAttributeNames[i] | |
| if (!newAttributes || !(name in newAttributes)) { | |
| domNode.removeAttribute(name) | |
| } | |
| } | |
| } | |
| if (newAttributes) { | |
| const newAttributeNames = Object.keys(newAttributes) | |
| for (let i = 0; i < newAttributeNames.length; i++) { | |
| const name = newAttributeNames[i] | |
| const oldValue = oldAttributes && oldAttributes[name] | |
| const newValue = newAttributes[name] | |
| if (newValue !== oldValue) { | |
| domNode.setAttribute(name, newValue) | |
| } | |
| } | |
| } | |
| } | |
| function updateRef (domNode, oldRefName, newRefName, refs) { | |
| if (newRefName !== oldRefName) { | |
| if (oldRefName && refs[oldRefName] === domNode) delete refs[oldRefName] | |
| if (newRefName) refs[newRefName] = domNode | |
| } | |
| } | |
| function updateEventListeners (domNode, oldVirtualNode, newVirtualNode, listenerContext) { | |
| const oldListeners = oldVirtualNode && oldVirtualNode.props && oldVirtualNode.props.on | |
| const newListeners = newVirtualNode.props && newVirtualNode.props.on | |
| for (const eventName in oldListeners) { | |
| if (!(newListeners && eventName in newListeners)) { | |
| let listenerToRemove | |
| if (oldVirtualNode && oldVirtualNode.boundListeners && oldVirtualNode.boundListeners[eventName]) { | |
| listenerToRemove = oldVirtualNode.boundListeners[eventName] | |
| } else { | |
| listenerToRemove =oldListeners[eventName] | |
| } | |
| domNode.removeEventListener(eventName, listenerToRemove) | |
| } | |
| } | |
| for (const eventName in newListeners) { | |
| const oldListener = oldListeners && oldListeners[eventName] | |
| const newListener = newListeners[eventName] | |
| if (newListener !== oldListener) { | |
| if (oldListener) { | |
| let listenerToRemove | |
| if (oldVirtualNode && oldVirtualNode.boundListeners && oldVirtualNode.boundListeners[eventName]) { | |
| listenerToRemove = oldVirtualNode.boundListeners[eventName] | |
| } else { | |
| listenerToRemove = oldListener | |
| } | |
| domNode.removeEventListener(eventName, listenerToRemove) | |
| } | |
| let listenerToAdd | |
| if (listenerContext) { | |
| listenerToAdd = newListener.bind(listenerContext) | |
| if (!newVirtualNode.boundListeners) newVirtualNode.boundListeners = {} | |
| newVirtualNode.boundListeners[eventName] = listenerToAdd | |
| } else { | |
| listenerToAdd = newListener | |
| } | |
| domNode.addEventListener(eventName, listenerToAdd) | |
| } | |
| } | |
| } | |
| },{"./event-listener-props":4,"./svg-attribute-translations":8,"./svg-tags":9}],"etch":[function(require,module,exports){ | |
| const dom = require('./dom') | |
| const render = require('./render') | |
| const {initialize, update, updateSync, destroy, destroySync} = require('./component-helpers') | |
| const {setScheduler, getScheduler} = require('./scheduler-assignment') | |
| module.exports = { | |
| dom, render, | |
| initialize, update, updateSync, destroy, destroySync, | |
| setScheduler, getScheduler | |
| } | |
| },{"./component-helpers":1,"./dom":3,"./render":6,"./scheduler-assignment":7}]},{},[]) | |
| //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","lib/component-helpers.js","lib/default-scheduler.js","lib/dom.js","lib/event-listener-props.js","lib/patch.js","lib/render.js","lib/scheduler-assignment.js","lib/svg-attribute-translations.js","lib/svg-tags.js","lib/update-props.js","etch"],"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;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1EA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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/KA;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})","const render = require('./render')\nconst patch = require('./patch')\nconst {getScheduler} = require('./scheduler-assignment')\n\nconst componentsWithPendingUpdates = new WeakSet()\nlet syncUpdatesInProgressCounter = 0\nlet syncDestructionsInProgressCounter = 0\n\nfunction isValidVirtualNode (virtualNode) {\n  return virtualNode != null && virtualNode !== false\n}\n\n// This function associates a component object with a DOM element by calling\n// the components `render` method, assigning an `.element` property on the\n// object and also returning the element.\n//\n// It also assigns a `virtualNode` property based on the return value of the\n// `render` method. This will be used later by `performElementUpdate` to diff\n// the new results of `render` with the previous results when updating the\n// component's element.\n//\n// Finally, this function also associates the component with a `refs` object,\n// which is populated with references to elements based on `ref` properties on\n// nodes of the `virtual-dom` tree. Before calling into `virtual-dom` to create\n// the DOM tree, it pushes this `refs` object to a shared stack so it can be\n// accessed by hooks during the creation of individual elements.\nfunction initialize(component) {\n  if (typeof component.update !== 'function') {\n    throw new Error('Etch components must implement `update(props, children)`.')\n  }\n\n  let virtualNode = component.render()\n  if (!isValidVirtualNode(virtualNode)) {\n    let namePart = component.constructor && component.constructor.name ? ' in ' + component.constructor.name : ''\n    throw new Error('invalid falsy value ' + virtualNode + ' returned from render()' + namePart)\n  }\n\n  component.refs = {}\n  component.virtualNode = virtualNode\n  component.element = render(component.virtualNode, {\n    refs: component.refs, listenerContext: component\n  })\n}\n\n// This function receives a component that has already been associated with an\n// element via a previous call to `initialize` and updates this element by\n// calling `render` on the component.\n//\n// When called in normal circumstances, it uses the scheduler to defer this\n// update until the next animation frame, and will only perform one update of a\n// given component in a given frame. This means you can call `update`\n// repeatedly in a given tick without causing redundant updates.\n//\n// If this function called during another synchronous update (for example, as a\n// result of a call to `update` on a child component), the update is performed\n// synchronously.\n//\n// Returns a promise that will resolve when the requested update has been\n// completed.\nfunction update (component, replaceNode=true) {\n  if (syncUpdatesInProgressCounter > 0) {\n    updateSync(component, replaceNode)\n    return Promise.resolve()\n  }\n\n  let scheduler = getScheduler()\n\n  if (!componentsWithPendingUpdates.has(component)) {\n    componentsWithPendingUpdates.add(component)\n    scheduler.updateDocument(function () {\n      componentsWithPendingUpdates.delete(component)\n      updateSync(component, replaceNode)\n    })\n  }\n\n  return scheduler.getNextUpdatePromise()\n}\n\n// Synchronsly updates the DOM element associated with a component object. .\n// This method assumes the presence of `.element` and `.virtualNode`\n// properties on the component, which are assigned in the `initialize`\n// function.\n//\n// It calls `render` on the component to obtain the desired state of the DOM,\n// then `diff`s it with the previous state and `patch`es the element based on\n// the resulting diff. During the patch operation, it pushes the component's\n// `refs` object to a shared stack so that references to DOM elements can be\n// updated.\n//\n// If `update` is called during the invocation of `updateSync`,\n// the requests are processed synchronously as well. We track whether this is\n// the case by incrementing and decrementing `syncUpdatesInProgressCounter`\n// around the call.\n//\n// For now, etch does not allow the root tag of the `render` method to change\n// between invocations, because we want to preserve a one-to-one relationship\n// between component objects and DOM elements for simplicity.\nfunction updateSync (component, replaceNode=true) {\n  let newVirtualNode = component.render()\n  if (!isValidVirtualNode(newVirtualNode)) {\n    let namePart = component.constructor && component.constructor.name ? ' in ' + component.constructor.name : ''\n    throw new Error('invalid falsy value ' + newVirtualNode + ' returned from render()' + namePart)\n  }\n\n  syncUpdatesInProgressCounter++\n  let oldVirtualNode = component.virtualNode\n  let oldDomNode = component.element\n  let newDomNode = patch(oldVirtualNode, newVirtualNode, {\n    refs: component.refs,\n    listenerContext: component\n  })\n  component.virtualNode = newVirtualNode\n  if (newDomNode !== oldDomNode && !replaceNode) {\n    throw new Error('The root node type changed on update, but the update was performed with the replaceNode option set to false')\n  } else {\n    component.element = newDomNode\n  }\n\n  // We can safely perform additional writes after a DOM update synchronously,\n  // but any reads need to be deferred until all writes are completed to avoid\n  // DOM thrashing. Requested reads occur at the end of the the current frame\n  // if this method was invoked via the scheduler. Otherwise, if `updateSync`\n  // was invoked outside of the scheduler, the default scheduler will defer\n  // reads until the next animation frame.\n  if (typeof component.writeAfterUpdate === 'function') {\n    component.writeAfterUpdate()\n  }\n  if (typeof component.readAfterUpdate === 'function') {\n    getScheduler().readDocument(function () {\n      component.readAfterUpdate()\n    })\n  }\n\n  syncUpdatesInProgressCounter--\n}\n\n// Removes the component's associated element and calls `destroy` on any child\n// components. Normally, this function is asynchronous and will perform the\n// destruction on the next animation frame. If called as the result of another\n// update or destruction, it calls `destroy` on child components synchronously.\n// If called as the result of destroying a component higher in the DOM, the\n// element is not removed to avoid redundant DOM manipulation. Returns a promise\n// that resolves when the destruction is completed.\nfunction destroy (component, removeNode=true) {\n  if (syncUpdatesInProgressCounter > 0 || syncDestructionsInProgressCounter > 0) {\n    destroySync(component, removeNode)\n    return Promise.resolve()\n  }\n\n  let scheduler = getScheduler()\n  scheduler.updateDocument(function () {\n    destroySync(component, removeNode)\n  })\n  return scheduler.getNextUpdatePromise()\n}\n\n// A synchronous version of `destroy`.\n//\n// Note that we track whether `destroy` calls are in progress and only remove\n// the element if we are not a nested call.\nfunction destroySync (component, removeNode=true) {\n  syncDestructionsInProgressCounter++\n  destroyChildComponents(component.virtualNode)\n  if (syncDestructionsInProgressCounter === 1 && removeNode) component.element.remove()\n  syncDestructionsInProgressCounter--\n}\n\nfunction destroyChildComponents(virtualNode) {\n  if (virtualNode.component && typeof virtualNode.component.destroy === 'function') {\n    virtualNode.component.destroy()\n  } else if (virtualNode.children) {\n    virtualNode.children.forEach(destroyChildComponents)\n  }\n}\n\nmodule.exports = {\n  initialize,\n  update, updateSync,\n  destroy, destroySync\n}\n","// If the scheduler is not customized via `etch.setScheduler`, an instance of\n// this class will be used to schedule updates to the document. The\n// `updateDocument` method accepts functions to be run at some point in the\n// future, then runs them on the next animation frame.\nmodule.exports = class DefaultScheduler {\n  constructor () {\n    this.updateRequests = []\n    this.readRequests = []\n    this.pendingAnimationFrame = null\n    this.performUpdates = this.performUpdates.bind(this)\n    this.performingUpdates = false\n  }\n\n  // Enqueues functions that write to the DOM to be performed on the next\n  // animation frame. Functions passed to this method should *never* read from\n  // the DOM, because that could cause synchronous reflows.\n  updateDocument (fn) {\n    this.updateRequests.push(fn)\n    if (!this.pendingAnimationFrame) {\n      this.pendingAnimationFrame = window.requestAnimationFrame(this.performUpdates)\n    }\n  }\n\n  readDocument (fn) {\n    this.readRequests.push(fn)\n    if (!this.pendingAnimationFrame) {\n      this.pendingAnimationFrame = window.requestAnimationFrame(this.performUpdates)\n    }\n  }\n\n  // Returns a promise that will resolve at the end of the next update cycle,\n  // after all the functions passed to `updateDocument` and `updateDocumentSync`\n  // have been run.\n  getNextUpdatePromise () {\n    if (!this.nextUpdatePromise) {\n      this.nextUpdatePromise = new Promise(resolve => {\n        this.resolveNextUpdatePromise = resolve\n      })\n    }\n    return this.nextUpdatePromise\n  }\n\n  // Performs all the pending document updates. If running these update\n  // functions causes *more* updates to be enqueued, they are run synchronously\n  // in this update cycle without waiting for another frame.\n  performUpdates () {\n    while (this.updateRequests.length > 0) {\n      this.updateRequests.shift()()\n    }\n\n    // We don't clear the pending frame until all update requests are processed.\n    // This ensures updates requested within other updates are processed in the\n    // current frame.\n    this.pendingAnimationFrame = null\n\n    // Now that updates are processed, we can perform all pending document reads\n    // without the risk of interleaving them with writes and causing layout\n    // thrashing.\n    while (this.readRequests.length > 0) {\n      this.readRequests.shift()()\n    }\n\n    if (this.nextUpdatePromise) {\n      let resolveNextUpdatePromise = this.resolveNextUpdatePromise\n      this.nextUpdatePromise = null\n      this.resolveNextUpdatePromise = null\n      resolveNextUpdatePromise()\n    }\n  }\n}\n","const EVENT_LISTENER_PROPS = require('./event-listener-props')\nconst SVG_TAGS = require('./svg-tags')\n\nfunction dom (tag, props, ...children) {\n  for (let i = 0; i < children.length;) {\n    const child = children[i]\n    switch (typeof child) {\n      case 'string':\n      case 'number':\n        children[i] = {text: child}\n        i++\n        break;\n\n      case 'object':\n        if (Array.isArray(child)) {\n          children.splice(i, 1, ...child)\n        } else if (!child) {\n          children.splice(i, 1)\n        } else {\n          i++\n        }\n        break;\n\n      default:\n        throw new Error(`Invalid child node: ${child}`)\n    }\n  }\n\n  if (props) {\n    for (const propName in props) {\n      const eventName = EVENT_LISTENER_PROPS[propName]\n      if (eventName) {\n        if (!props.on) props.on = {}\n        props.on[eventName] = props[propName]\n      }\n    }\n\n    if (props.class) {\n      props.className = props.class\n    }\n  }\n\n  return {tag, props, children}\n}\n\nconst HTML_TAGS = [\n  'a', 'abbr', 'address', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo',\n  'blockquote', 'body', 'button', 'canvas', 'caption', 'cite', 'code',\n  'colgroup', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl',\n  'dt', 'em', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2',\n  'h3', 'h4', 'h5', 'h6', 'head', 'header', 'html', 'i', 'iframe', 'ins', 'kbd',\n  'label', 'legend', 'li', 'main', 'map', 'mark', 'menu', 'meter', 'nav',\n  'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'pre',\n  'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section',\n  'select', 'small', 'span', 'strong', 'style', 'sub', 'summary', 'sup',\n  'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title',\n  'tr', 'u', 'ul', 'var', 'video', 'area', 'base', 'br', 'col', 'command',\n  'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source',\n  'track', 'wbr'\n]\n\nfor (const tagName of HTML_TAGS) {\n  dom[tagName] = (props, ...children) => {\n    return dom(tagName, props, ...children)\n  }\n}\n\nfor (const tagName of SVG_TAGS) {\n  dom[tagName] = (props, ...children) => {\n    return dom(tagName, props, ...children)\n  }\n}\n\n\nmodule.exports = dom\n","module.exports = {\n  onCopy: 'copy',\n  onCut: 'cut',\n  onPaste: 'paste',\n  onCompositionEnd: 'compositionend',\n  onCompositionStart: 'compositionstart',\n  onCompositionUpdate: 'compositionupdate',\n  onKeyDown: 'keydown',\n  onKeyPress: 'keypress',\n  onKeyUp: 'keyup',\n  onFocus: 'focus',\n  onBlur: 'blur',\n  onChange: 'change',\n  onInput: 'input',\n  onSubmit: 'submit',\n  onClick: 'click',\n  onContextMenu: 'contextmenu',\n  onDoubleClick: 'doubleclick',\n  onDrag: 'drag',\n  onDragEnd: 'dragend',\n  onDragEnter: 'dragenter',\n  onDragExit: 'dragexit',\n  onDragLeave: 'dragleave',\n  onDragOver: 'dragover',\n  onDragStart: 'dragstart',\n  onDrop: 'drop',\n  onMouseDown: 'mousedown',\n  onMouseEnter: 'mousenter',\n  onMouseLeave: 'mouseleave',\n  onMouseMove: 'mousemove',\n  onMouseOut: 'mouseout',\n  onMouseOver: 'mouseover',\n  onMouseUp: 'mouseup',\n  onSelect: 'select',\n  onTouchCancel: 'touchcancel',\n  onTouchEnd: 'touchend',\n  onTouchMove: 'touchmove',\n  onTouchStart: 'touchstart',\n  onScroll: 'scroll',\n  onWheel: 'wheel',\n  onAbort: 'abort',\n  onCanPlay: 'canplay',\n  onCanPlayThrough: 'canplaythrough',\n  onDurationChange: 'durationchange',\n  onEmptied: 'emptied',\n  onEncrypted: 'encrypted',\n  onEnded: 'ended',\n  onError: 'error',\n  onLoadedData: 'loadeddata',\n  onLoadedMetadata: 'loadedmetadat',\n  onLoadStart: 'loadstart',\n  onPause: 'pause',\n  onPlay: 'play',\n  onPlaying: 'playing',\n  onProgress: 'progress',\n  onRateChange: 'ratechange',\n  onSeeked: 'seeked',\n  onSeeking: 'seeking',\n  onStalled: 'stalled',\n  onSuspend: 'suspend',\n  onTimeUpdate: 'timeupdate',\n  onVolumeChange: 'volumechange',\n  onWaiting: 'waiting',\n  onLoad: 'load',\n  onError: 'error',\n  onAnimationStart: 'animationstart',\n  onAnimationEnd: 'animationend',\n  onAnimationIteration: 'animationiteration',\n  onTransitionEnd: 'transitionend'\n}\n","const render = require('./render')\nconst updateProps = require('./update-props')\n\nfunction patch (oldVirtualNode, newVirtualNode, options) {\n  const oldNode = oldVirtualNode.domNode\n  if (virtualNodesAreEqual(oldVirtualNode, newVirtualNode)) {\n    let newNode\n    if (newVirtualNode.text != null) {\n      oldNode.nodeValue = newVirtualNode.text\n      newNode = oldNode\n    } else {\n      if (typeof newVirtualNode.tag === 'function') {\n        newNode = updateComponent(oldVirtualNode, newVirtualNode, options)\n      } else {\n        updateChildren(oldNode, oldVirtualNode.children, newVirtualNode.children, options)\n        updateProps(oldNode, oldVirtualNode, newVirtualNode, options)\n        newNode = oldNode\n      }\n    }\n    newVirtualNode.domNode = newNode\n    if (newNode !== oldNode && oldNode.parentNode) {\n      oldNode.parentNode.replaceChild(newNode, oldNode)\n    }\n    return newNode\n  } else {\n    const parentNode = oldNode.parentNode\n    const nextSibling = oldNode.nextSibling\n    removeVirtualNode(oldVirtualNode, options && options.refs)\n    const newNode = render(newVirtualNode, options)\n    if (parentNode) parentNode.insertBefore(newNode, nextSibling)\n    newVirtualNode.domNode = newNode\n    return newNode\n  }\n}\n\nfunction updateComponent (oldVirtualNode, newVirtualNode, options) {\n  const {component, props: oldProps} = oldVirtualNode\n  let {props: newProps, children: newChildren} = newVirtualNode\n  newVirtualNode.component = component\n  if (options && options.refs) {\n    const refs = options.refs\n    const oldRefName = oldProps && oldProps.ref\n    const newRefName = newProps && newProps.ref\n    if (newRefName !== oldRefName) {\n      if (oldRefName && refs[oldRefName] === component) delete refs[oldRefName]\n      if (newRefName) refs[newRefName] = component\n    }\n  }\n  component.update(newProps || {}, newChildren)\n  return component.element\n}\n\nfunction updateChildren (parentElement, oldChildren, newChildren, options) {\n  let oldStartIndex = 0\n  let oldEndIndex = oldChildren.length - 1\n  let oldStartChild = oldChildren[0]\n  let oldEndChild = oldChildren[oldEndIndex]\n\n  let newStartIndex = 0\n  let newEndIndex = newChildren.length - 1\n  let newStartChild = newChildren[0]\n  let newEndChild = newChildren[newEndIndex]\n\n  let oldIndicesByKey\n\n  while (oldStartIndex <= oldEndIndex && newStartIndex <= newEndIndex) {\n    if (!oldStartChild) {\n      oldStartChild = oldChildren[++oldStartIndex]\n    } else if (!oldEndChild) {\n      oldEndChild = oldChildren[--oldEndIndex]\n    } else if (virtualNodesAreEqual(oldStartChild, newStartChild)) {\n      patch(oldStartChild, newStartChild, options)\n      oldStartChild = oldChildren[++oldStartIndex]\n      newStartChild = newChildren[++newStartIndex]\n    } else if (virtualNodesAreEqual(oldEndChild, newEndChild)) {\n      patch(oldEndChild, newEndChild, options)\n      oldEndChild = oldChildren[--oldEndIndex]\n      newEndChild = newChildren[--newEndIndex]\n    } else if (virtualNodesAreEqual(oldStartChild, newEndChild)) {\n      patch(oldStartChild, newEndChild, options)\n      parentElement.insertBefore(oldStartChild.domNode, oldEndChild.domNode.nextSibling)\n      oldStartChild = oldChildren[++oldStartIndex]\n      newEndChild = newChildren[--newEndIndex]\n    } else if (virtualNodesAreEqual(oldEndChild, newStartChild)) {\n      patch(oldEndChild, newStartChild, options)\n      parentElement.insertBefore(oldEndChild.domNode, oldStartChild.domNode);\n      oldEndChild = oldChildren[--oldEndIndex]\n      newStartChild = newChildren[++newStartIndex]\n    } else {\n      if (!oldIndicesByKey) oldIndicesByKey = mapOldKeysToIndices(oldChildren, oldStartIndex, oldEndIndex)\n      const key = getKey(newStartChild)\n      const oldIndex = key ? oldIndicesByKey.get(key) : null\n      if (oldIndex == null) {\n        parentElement.insertBefore(render(newStartChild, options), oldStartChild.domNode)\n        newStartChild = newChildren[++newStartIndex]\n      } else {\n        const oldChildToMove = oldChildren[oldIndex]\n        patch(oldChildToMove, newStartChild, options)\n        oldChildren[oldIndex] = undefined\n        parentElement.insertBefore(oldChildToMove.domNode, oldStartChild.domNode)\n        newStartChild = newChildren[++newStartIndex]\n      }\n    }\n  }\n\n  if (oldStartIndex > oldEndIndex) {\n    const subsequentElement = newChildren[newEndIndex + 1] ? newChildren[newEndIndex + 1].domNode : null\n    for (let i = newStartIndex; i <= newEndIndex; i++) {\n      parentElement.insertBefore(render(newChildren[i], options), subsequentElement)\n    }\n  } else if (newStartIndex > newEndIndex) {\n    for (let i = oldStartIndex; i <= oldEndIndex; i++) {\n      const child = oldChildren[i]\n      if (child) removeVirtualNode(child, options && options.refs)\n    }\n  }\n}\n\nfunction removeVirtualNode (virtualNode, refs, removeDOMNode = true) {\n  const {domNode, props, children, component} = virtualNode\n  const ref = props && props.ref\n  if (component) {\n    if (refs && ref && refs[ref] === component) delete refs[ref]\n    if (typeof component.destroy === 'function') component.destroy()\n  } else {\n    if (refs && ref && refs[ref] === domNode) delete refs[ref]\n    if (children) {\n      for (let i = 0; i < children.length; i++) {\n        removeVirtualNode(children[i], refs, false)\n      }\n    }\n  }\n\n  if (removeDOMNode) domNode.remove()\n}\n\nfunction virtualNodesAreEqual (oldVirtualNode, newVirtualNode) {\n  return (\n    getKey(oldVirtualNode) === getKey(newVirtualNode)\n      && oldVirtualNode.tag === newVirtualNode.tag\n  )\n}\n\nfunction getKey (virtualNode) {\n  return virtualNode.props ? virtualNode.props.key : undefined\n}\n\nfunction mapOldKeysToIndices (children, startIndex, endIndex) {\n  let oldIndicesByKey = new Map()\n  for (let i = startIndex; i <= endIndex; i++) {\n    const key = getKey(children[i])\n    if (key) oldIndicesByKey.set(key, i)\n  }\n  return oldIndicesByKey\n}\n\nmodule.exports = patch\n","const updateProps = require('./update-props')\nconst SVG_TAGS = require('./svg-tags')\n\nfunction render (virtualNode, options) {\n  let domNode\n  if (virtualNode.text != null) {\n    domNode = document.createTextNode(virtualNode.text)\n  } else {\n    const {tag, children} = virtualNode\n    let {props} = virtualNode\n\n    if (typeof tag === 'function') {\n      let ref\n      if (props && props.ref) {\n        ref = props.ref\n      }\n      const component = new tag(props || {}, children)\n      virtualNode.component = component\n      domNode = component.element\n      if (options && options.refs && ref) {\n        options.refs[ref] = component\n      }\n    } else if (SVG_TAGS.has(tag)) {\n      domNode = document.createElementNS(\"http://www.w3.org/2000/svg\", tag);\n      if (children) addChildren(domNode, children, options)\n      if (props) updateProps(domNode, null, virtualNode, options)\n    } else {\n      domNode = document.createElement(tag)\n      if (children) addChildren(domNode, children, options)\n      if (props) updateProps(domNode, null, virtualNode, options)\n    }\n  }\n  virtualNode.domNode = domNode\n  return domNode\n}\n\nfunction addChildren (parent, children, options) {\n  for (let i = 0; i < children.length; i++) {\n    parent.appendChild(render(children[i], options))\n  }\n}\n\nmodule.exports = render\n","// This file implements getter and setter functions for a scheduler to be used\n// by this library when updating the DOM. The scheduler's job is to ensure that\n// DOM interaction is performed efficiently. When using `etch` in Atom, you\n// should tell `etch` to use Atom's scheduler by calling\n// `setScheduler(atom.views)`.\n//\n// Schedulers should support the following interface:\n// * `updateDocument(fn)` This method is asynchronous. It enqueues functions to\n// be executed later.\n// * `getNextUpdatePromise()` This function should return a promise that\n// resolves after all pending document update functions have been invoked.\n//\n// Schedulers could support the following optional methods, which are supported\n// by Atom's scheduler.\n//\n// * `readDocument` This method can be invoked by clients other than `etch` when\n// it is necessary to read from the DOM. Functions enqueued via this method\n// should not be run until all document update functions have been executed.\n// Batching updates and reads in this way will prevent forced synchronous\n// reflows.\n// * `pollDocument` This method is similar to `readDocument`, but it runs the\n// associated functions repeatedly. Again, they should be scheduled in such a\n// way so as to avoid synchronous reflows.\n\nconst DefaultScheduler = require('./default-scheduler')\n\nlet scheduler = null\n\nmodule.exports.setScheduler = function setScheduler (customScheduler) {\n  scheduler = customScheduler\n}\n\nmodule.exports.getScheduler = function getScheduler () {\n  if (!scheduler) {\n    scheduler = new DefaultScheduler()\n  }\n  return scheduler\n}\n","// Based on https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute\nmodule.exports = new Map([\n  ['accentHeight', 'accent-height'],\n  ['alignmentBaseline', 'alignment-baseline'],\n  ['arabicForm', 'arabic-form'],\n  ['baselineShift', 'baseline-shift'],\n  ['capHeight', 'cap-height'],\n  ['className', 'class'],\n  ['clipPath', 'clip-path'],\n  ['clipRule', 'clip-rule'],\n  ['colorInterpolation', 'color-interpolation'],\n  ['colorInterpolationFilters', 'color-interpolation-filters'],\n  ['colorProfile', 'color-profile'],\n  ['colorRendering', 'color-rendering'],\n  ['dominantBaseline', 'dominant-baseline'],\n  ['enableBackground', 'enable-background'],\n  ['fillOpacity', 'fill-opacity'],\n  ['fillRule', 'fill-rule'],\n  ['floodColor', 'flood-color'],\n  ['floodOpacity', 'flood-opacity'],\n  ['fontFamily', 'font-family'],\n  ['fontSize', 'font-size'],\n  ['fontSizeAdjust', 'font-size-adjust'],\n  ['fontStretch', 'font-stretch'],\n  ['fontStyle', 'font-style'],\n  ['fontVariant', 'font-variant'],\n  ['fontWeight', 'font-weight'],\n  ['glyphName', 'glyph-name'],\n  ['glyphOrientationHorizontal', 'glyph-orientation-horizontal'],\n  ['glyphOrientationVertical', 'glyph-orientation-vertical'],\n  ['horizAdvX', 'horiz-adv-x'],\n  ['horizOriginX', 'horiz-origin-x'],\n  ['letterSpacing', 'letter-spacing'],\n  ['lightingColor', 'lighting-color'],\n  ['markerEnd', 'marker-end'],\n  ['markerMid', 'marker-mid'],\n  ['markerStart', 'marker-start'],\n  ['overlinePosition', 'overline-position'],\n  ['overlineThickness', 'overline-thickness'],\n  ['panose1', 'panose-1'],\n  ['paintOrder', 'paint-order'],\n  ['pointerEvents', 'pointer-events'],\n  ['renderingIntent', 'rendering-intent'],\n  ['shapeRendering', 'shape-rendering'],\n  ['stopColor', 'stop-color'],\n  ['stopOpacity', 'stop-opacity'],\n  ['strikethroughPosition', 'strikethrough-position'],\n  ['strikethroughThickness', 'strikethrough-thickness'],\n  ['strokeDasharray', 'stroke-dasharray'],\n  ['strokeDashoffset', 'stroke-dashoffset'],\n  ['strokeLinecap', 'stroke-linecap'],\n  ['strokeLinejoin', 'stroke-linejoin'],\n  ['strokeMiterlimit', 'stroke-miterlimit'],\n  ['strokeOpacity', 'stroke-opacity'],\n  ['strokeWidth', 'stroke-width'],\n  ['textAnchor', 'text-anchor'],\n  ['textDecoration', 'text-decoration'],\n  ['textRendering', 'text-rendering'],\n  ['underlinePosition', 'underline-position'],\n  ['underlineThickness', 'underline-thickness'],\n  ['unicodeBidi', 'unicode-bidi'],\n  ['unicodeRange', 'unicode-range'],\n  ['unitsPerEm', 'units-per-em'],\n  ['vAlphabetic', 'v-alphabetic'],\n  ['vHanging', 'v-hanging'],\n  ['vIdeographic', 'v-ideographic'],\n  ['vMathematical', 'v-mathematical'],\n  ['vertAdvY', 'vert-adv-y'],\n  ['vertOriginX', 'vert-origin-x'],\n  ['vertOriginY', 'vert-origin-y'],\n  ['wordSpacing', 'word-spacing'],\n  ['writingMode', 'writing-mode'],\n  ['xHeight', 'x-height'],\n])\n","// taken from https://github.com/facebook/react/blob/67f8524e88abbf1ac0fd86d38a0477d11fbc7b3e/src/isomorphic/classic/element/ReactDOMFactories.js#L153\nmodule.exports = new Set([\n  'circle',\n  'clipPath',\n  'defs',\n  'ellipse',\n  'g',\n  'image',\n  'line',\n  'linearGradient',\n  'mask',\n  'path',\n  'pattern',\n  'polygon',\n  'polyline',\n  'radialGradient',\n  'rect',\n  'stop',\n  'svg',\n  'text',\n  'tspan'\n])\n","const EVENT_LISTENER_PROPS = require('./event-listener-props')\nconst SVG_TAGS = require('./svg-tags')\nconst SVG_ATTRIBUTE_TRANSLATIONS = require('./svg-attribute-translations')\nconst EMPTY = ''\n\nmodule.exports = function (domNode, oldVirtualNode, newVirtualNode, options) {\n  const oldProps = oldVirtualNode && oldVirtualNode.props\n  const newProps = newVirtualNode.props\n\n  let refs, listenerContext\n  if (options) {\n    refs = options.refs\n    listenerContext = options.listenerContext\n  }\n  updateProps(domNode, oldVirtualNode, oldProps, newVirtualNode, newProps)\n  if (refs) updateRef(domNode, oldProps && oldProps.ref, newProps && newProps.ref, refs)\n  updateEventListeners(domNode, oldVirtualNode, newVirtualNode, listenerContext)\n}\n\nfunction updateProps (domNode, oldVirtualNode, oldProps, newVirtualNode, newProps) {\n  if (oldProps) {\n    const oldPropsNames = Object.keys(oldProps)\n    for (let i = 0; i < oldPropsNames.length; i++) {\n      const name = oldPropsNames[i]\n      if (name === 'ref' || name === 'on') continue\n      if (name in EVENT_LISTENER_PROPS) continue\n      if (!newProps || !(name in newProps)) {\n        if (name === 'dataset') {\n          updateProps(domNode.dataset, null, oldProps && oldProps.dataset, null, null)\n        } else if (name !== 'innerHTML' && oldVirtualNode && SVG_TAGS.has(oldVirtualNode.tag)) {\n          domNode.removeAttribute(SVG_ATTRIBUTE_TRANSLATIONS.get(name) || name)\n        } else {\n          // Clear property for objects that don't support deletion (e.g. style\n          // or className). If we used null instead of an empty string, the DOM\n          // could sometimes stringify the value and mistakenly assign 'null'.\n          domNode[name] = EMPTY\n          delete domNode[name]\n        }\n      }\n    }\n  }\n\n  if (newProps) {\n    const newPropsNames = Object.keys(newProps)\n    for (let i = 0; i < newPropsNames.length; i++) {\n      const name = newPropsNames[i]\n      if (name === 'ref' || name === 'on') continue\n      if (name in EVENT_LISTENER_PROPS) continue\n      const oldValue = oldProps && oldProps[name]\n      const newValue = newProps[name]\n      if (name === 'dataset') {\n        updateNestedProps(domNode.dataset, oldValue, newValue, false)\n      } else if (name === 'style' && typeof newValue !== 'string') {\n        let oldProps = oldValue\n        if (typeof oldProps === 'string') {\n          domNode.style = ''\n          oldProps = null\n        }\n        updateNestedProps(domNode.style, oldProps, newValue, true)\n      } else if (name === 'attributes') {\n        updateAttributes(domNode, oldValue, newValue)\n      } else {\n        if (newValue !== oldValue) {\n          if (name !== 'innerHTML' && newVirtualNode && SVG_TAGS.has(newVirtualNode.tag)) {\n            domNode.setAttribute(SVG_ATTRIBUTE_TRANSLATIONS.get(name) || name, newValue)\n          } else {\n            domNode[name] = newValue\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction updateNestedProps (domProps, oldProps, newProps, isStyleObject) {\n  if (oldProps) {\n    const oldPropsNames = Object.keys(oldProps)\n    for (let i = 0; i < oldPropsNames.length; i++) {\n      const name = oldPropsNames[i]\n      if (!newProps || !(name in newProps)) {\n        if (isStyleObject) {\n          domProps[name] = EMPTY\n        } else {\n          delete domProps[name]\n        }\n      }\n    }\n  }\n\n  if (newProps) {\n    const newPropsNames = Object.keys(newProps)\n    for (let i = 0; i < newPropsNames.length; i++) {\n      const name = newPropsNames[i]\n      const oldValue = oldProps && oldProps[name]\n      const newValue = newProps[name]\n      if (newValue !== oldValue) {\n        domProps[name] = newValue\n      }\n    }\n  }\n}\n\nfunction updateAttributes (domNode, oldAttributes, newAttributes) {\n  if (oldAttributes) {\n    const oldAttributeNames = Object.keys(oldAttributes)\n    for (let i = 0; i < oldAttributeNames.length; i++) {\n      const name = oldAttributeNames[i]\n      if (!newAttributes || !(name in newAttributes)) {\n        domNode.removeAttribute(name)\n      }\n    }\n  }\n\n  if (newAttributes) {\n    const newAttributeNames = Object.keys(newAttributes)\n    for (let i = 0; i < newAttributeNames.length; i++) {\n      const name = newAttributeNames[i]\n      const oldValue = oldAttributes && oldAttributes[name]\n      const newValue = newAttributes[name]\n      if (newValue !== oldValue) {\n        domNode.setAttribute(name, newValue)\n      }\n    }\n  }\n}\n\nfunction updateRef (domNode, oldRefName, newRefName, refs) {\n  if (newRefName !== oldRefName) {\n    if (oldRefName && refs[oldRefName] === domNode) delete refs[oldRefName]\n    if (newRefName) refs[newRefName] = domNode\n  }\n}\n\nfunction updateEventListeners (domNode, oldVirtualNode, newVirtualNode, listenerContext) {\n  const oldListeners = oldVirtualNode && oldVirtualNode.props && oldVirtualNode.props.on\n  const newListeners = newVirtualNode.props && newVirtualNode.props.on\n\n  for (const eventName in oldListeners) {\n    if (!(newListeners && eventName in newListeners)) {\n      let listenerToRemove\n      if (oldVirtualNode && oldVirtualNode.boundListeners && oldVirtualNode.boundListeners[eventName]) {\n        listenerToRemove = oldVirtualNode.boundListeners[eventName]\n      } else {\n        listenerToRemove =oldListeners[eventName]\n      }\n      domNode.removeEventListener(eventName, listenerToRemove)\n    }\n  }\n\n  for (const eventName in newListeners) {\n    const oldListener = oldListeners && oldListeners[eventName]\n    const newListener = newListeners[eventName]\n\n    if (newListener !== oldListener) {\n      if (oldListener) {\n        let listenerToRemove\n        if (oldVirtualNode && oldVirtualNode.boundListeners && oldVirtualNode.boundListeners[eventName]) {\n          listenerToRemove = oldVirtualNode.boundListeners[eventName]\n        } else {\n          listenerToRemove = oldListener\n        }\n        domNode.removeEventListener(eventName, listenerToRemove)\n      }\n      let listenerToAdd\n      if (listenerContext) {\n        listenerToAdd = newListener.bind(listenerContext)\n        if (!newVirtualNode.boundListeners) newVirtualNode.boundListeners = {}\n        newVirtualNode.boundListeners[eventName] = listenerToAdd\n      } else {\n        listenerToAdd = newListener\n      }\n      domNode.addEventListener(eventName, listenerToAdd)\n    }\n  }\n}\n","const dom = require('./dom')\nconst render = require('./render')\nconst {initialize, update, updateSync, destroy, destroySync} = require('./component-helpers')\nconst {setScheduler, getScheduler} = require('./scheduler-assignment')\n\nmodule.exports = {\n  dom, render,\n  initialize, update, updateSync, destroy, destroySync,\n  setScheduler, getScheduler\n}\n"]} | |
| const etch = require('etch') | |
| function toHTMLElement(vdom) { | |
| const component = { | |
| update() { /* noop */ }, | |
| render () { return vdom } | |
| } | |
| etch.initialize(component) | |
| return component.element | |
| } | |
| const domElement = toHTMLElement(etch.dom.div(null, etch.dom.span(null, 'Hello!'))) | |
| document.body.appendChild(domElement) | |
| ;}, 0) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "name": "requirebin-sketch", | |
| "version": "1.0.0", | |
| "dependencies": { | |
| "etch": "0.11.0" | |
| } | |
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <body> --> |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <head> --> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment