| !function() { |
| 'use strict'; |
| function VNode() {} |
| function h(nodeName, attributes) { |
| var lastSimple, child, simple, i, children = EMPTY_CHILDREN; |
| for (i = arguments.length; i-- > 2; ) stack.push(arguments[i]); |
| if (attributes && null != attributes.children) { |
| if (!stack.length) stack.push(attributes.children); |
| delete attributes.children; |
| } |
| while (stack.length) if ((child = stack.pop()) && void 0 !== child.pop) for (i = child.length; i--; ) stack.push(child[i]); else { |
| if ('boolean' == typeof child) child = null; |
| if (simple = 'function' != typeof nodeName) if (null == child) child = ''; else if ('number' == typeof child) child = String(child); else if ('string' != typeof child) simple = !1; |
| if (simple && lastSimple) children[children.length - 1] += child; else if (children === EMPTY_CHILDREN) children = [ child ]; else children.push(child); |
| lastSimple = simple; |
| } |
| var p = new VNode(); |
| p.nodeName = nodeName; |
| p.children = children; |
| p.attributes = null == attributes ? void 0 : attributes; |
| p.key = null == attributes ? void 0 : attributes.key; |
| if (void 0 !== options.vnode) options.vnode(p); |
| return p; |
| } |
| function extend(obj, props) { |
| for (var i in props) obj[i] = props[i]; |
| return obj; |
| } |
| function cloneElement(vnode, props) { |
| return h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children); |
| } |
| function enqueueRender(component) { |
| if (!component.__d && (component.__d = !0) && 1 == items.push(component)) (options.debounceRendering || defer)(rerender); |
| } |
| function rerender() { |
| var p, list = items; |
| items = []; |
| while (p = list.pop()) if (p.__d) renderComponent(p); |
| } |
| function isSameNodeType(node, vnode, hydrating) { |
| if ('string' == typeof vnode || 'number' == typeof vnode) return void 0 !== node.splitText; |
| if ('string' == typeof vnode.nodeName) return !node._componentConstructor && isNamedNode(node, vnode.nodeName); else return hydrating || node._componentConstructor === vnode.nodeName; |
| } |
| function isNamedNode(node, nodeName) { |
| return node.__n === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase(); |
| } |
| function getNodeProps(vnode) { |
| var props = extend({}, vnode.attributes); |
| props.children = vnode.children; |
| var defaultProps = vnode.nodeName.defaultProps; |
| if (void 0 !== defaultProps) for (var i in defaultProps) if (void 0 === props[i]) props[i] = defaultProps[i]; |
| return props; |
| } |
| function createNode(nodeName, isSvg) { |
| var node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName); |
| node.__n = nodeName; |
| return node; |
| } |
| function removeNode(node) { |
| var parentNode = node.parentNode; |
| if (parentNode) parentNode.removeChild(node); |
| } |
| function setAccessor(node, name, old, value, isSvg) { |
| if ('className' === name) name = 'class'; |
| if ('key' === name) ; else if ('ref' === name) { |
| if (old) old(null); |
| if (value) value(node); |
| } else if ('class' === name && !isSvg) node.className = value || ''; else if ('style' === name) { |
| if (!value || 'string' == typeof value || 'string' == typeof old) node.style.cssText = value || ''; |
| if (value && 'object' == typeof value) { |
| if ('string' != typeof old) for (var i in old) if (!(i in value)) node.style[i] = ''; |
| for (var i in value) node.style[i] = 'number' == typeof value[i] && !1 === IS_NON_DIMENSIONAL.test(i) ? value[i] + 'px' : value[i]; |
| } |
| } else if ('dangerouslySetInnerHTML' === name) { |
| if (value) node.innerHTML = value.__html || ''; |
| } else if ('o' == name[0] && 'n' == name[1]) { |
| var useCapture = name !== (name = name.replace(/Capture$/, '')); |
| name = name.toLowerCase().substring(2); |
| if (value) { |
| if (!old) node.addEventListener(name, eventProxy, useCapture); |
| } else node.removeEventListener(name, eventProxy, useCapture); |
| (node.__l || (node.__l = {}))[name] = value; |
| } else if ('list' !== name && 'type' !== name && !isSvg && name in node) { |
| setProperty(node, name, null == value ? '' : value); |
| if (null == value || !1 === value) node.removeAttribute(name); |
| } else { |
| var ns = isSvg && name !== (name = name.replace(/^xlink\:?/, '')); |
| if (null == value || !1 === value) if (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase()); else node.removeAttribute(name); else if ('function' != typeof value) if (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value); else node.setAttribute(name, value); |
| } |
| } |
| function setProperty(node, name, value) { |
| try { |
| node[name] = value; |
| } catch (e) {} |
| } |
| function eventProxy(e) { |
| return this.__l[e.type](options.event && options.event(e) || e); |
| } |
| function flushMounts() { |
| var c; |
| while (c = mounts.pop()) { |
| if (options.afterMount) options.afterMount(c); |
| if (c.componentDidMount) c.componentDidMount(); |
| } |
| } |
| function diff(dom, vnode, context, mountAll, parent, componentRoot) { |
| if (!diffLevel++) { |
| isSvgMode = null != parent && void 0 !== parent.ownerSVGElement; |
| hydrating = null != dom && !('__preactattr_' in dom); |
| } |
| var ret = idiff(dom, vnode, context, mountAll, componentRoot); |
| if (parent && ret.parentNode !== parent) parent.appendChild(ret); |
| if (!--diffLevel) { |
| hydrating = !1; |
| if (!componentRoot) flushMounts(); |
| } |
| return ret; |
| } |
| function idiff(dom, vnode, context, mountAll, componentRoot) { |
| var out = dom, prevSvgMode = isSvgMode; |
| if (null == vnode || 'boolean' == typeof vnode) vnode = ''; |
| if ('string' == typeof vnode || 'number' == typeof vnode) { |
| if (dom && void 0 !== dom.splitText && dom.parentNode && (!dom._component || componentRoot)) { |
| if (dom.nodeValue != vnode) dom.nodeValue = vnode; |
| } else { |
| out = document.createTextNode(vnode); |
| if (dom) { |
| if (dom.parentNode) dom.parentNode.replaceChild(out, dom); |
| recollectNodeTree(dom, !0); |
| } |
| } |
| out.__preactattr_ = !0; |
| return out; |
| } |
| var vnodeName = vnode.nodeName; |
| if ('function' == typeof vnodeName) return buildComponentFromVNode(dom, vnode, context, mountAll); |
| isSvgMode = 'svg' === vnodeName ? !0 : 'foreignObject' === vnodeName ? !1 : isSvgMode; |
| vnodeName = String(vnodeName); |
| if (!dom || !isNamedNode(dom, vnodeName)) { |
| out = createNode(vnodeName, isSvgMode); |
| if (dom) { |
| while (dom.firstChild) out.appendChild(dom.firstChild); |
| if (dom.parentNode) dom.parentNode.replaceChild(out, dom); |
| recollectNodeTree(dom, !0); |
| } |
| } |
| var fc = out.firstChild, props = out.__preactattr_, vchildren = vnode.children; |
| if (null == props) { |
| props = out.__preactattr_ = {}; |
| for (var a = out.attributes, i = a.length; i--; ) props[a[i].name] = a[i].value; |
| } |
| if (!hydrating && vchildren && 1 === vchildren.length && 'string' == typeof vchildren[0] && null != fc && void 0 !== fc.splitText && null == fc.nextSibling) { |
| if (fc.nodeValue != vchildren[0]) fc.nodeValue = vchildren[0]; |
| } else if (vchildren && vchildren.length || null != fc) innerDiffNode(out, vchildren, context, mountAll, hydrating || null != props.dangerouslySetInnerHTML); |
| diffAttributes(out, vnode.attributes, props); |
| isSvgMode = prevSvgMode; |
| return out; |
| } |
| function innerDiffNode(dom, vchildren, context, mountAll, isHydrating) { |
| var j, c, f, vchild, child, originalChildren = dom.childNodes, children = [], keyed = {}, keyedLen = 0, min = 0, len = originalChildren.length, childrenLen = 0, vlen = vchildren ? vchildren.length : 0; |
| if (0 !== len) for (var i = 0; i < len; i++) { |
| var _child = originalChildren[i], props = _child.__preactattr_, key = vlen && props ? _child._component ? _child._component.__k : props.key : null; |
| if (null != key) { |
| keyedLen++; |
| keyed[key] = _child; |
| } else if (props || (void 0 !== _child.splitText ? isHydrating ? _child.nodeValue.trim() : !0 : isHydrating)) children[childrenLen++] = _child; |
| } |
| if (0 !== vlen) for (var i = 0; i < vlen; i++) { |
| vchild = vchildren[i]; |
| child = null; |
| var key = vchild.key; |
| if (null != key) { |
| if (keyedLen && void 0 !== keyed[key]) { |
| child = keyed[key]; |
| keyed[key] = void 0; |
| keyedLen--; |
| } |
| } else if (!child && min < childrenLen) for (j = min; j < childrenLen; j++) if (void 0 !== children[j] && isSameNodeType(c = children[j], vchild, isHydrating)) { |
| child = c; |
| children[j] = void 0; |
| if (j === childrenLen - 1) childrenLen--; |
| if (j === min) min++; |
| break; |
| } |
| child = idiff(child, vchild, context, mountAll); |
| f = originalChildren[i]; |
| if (child && child !== dom && child !== f) if (null == f) dom.appendChild(child); else if (child === f.nextSibling) removeNode(f); else dom.insertBefore(child, f); |
| } |
| if (keyedLen) for (var i in keyed) if (void 0 !== keyed[i]) recollectNodeTree(keyed[i], !1); |
| while (min <= childrenLen) if (void 0 !== (child = children[childrenLen--])) recollectNodeTree(child, !1); |
| } |
| function recollectNodeTree(node, unmountOnly) { |
| var component = node._component; |
| if (component) unmountComponent(component); else { |
| if (null != node.__preactattr_ && node.__preactattr_.ref) node.__preactattr_.ref(null); |
| if (!1 === unmountOnly || null == node.__preactattr_) removeNode(node); |
| removeChildren(node); |
| } |
| } |
| function removeChildren(node) { |
| node = node.lastChild; |
| while (node) { |
| var next = node.previousSibling; |
| recollectNodeTree(node, !0); |
| node = next; |
| } |
| } |
| function diffAttributes(dom, attrs, old) { |
| var name; |
| for (name in old) if ((!attrs || null == attrs[name]) && null != old[name]) setAccessor(dom, name, old[name], old[name] = void 0, isSvgMode); |
| for (name in attrs) if (!('children' === name || 'innerHTML' === name || name in old && attrs[name] === ('value' === name || 'checked' === name ? dom[name] : old[name]))) setAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode); |
| } |
| function collectComponent(component) { |
| var name = component.constructor.name; |
| (components[name] || (components[name] = [])).push(component); |
| } |
| function createComponent(Ctor, props, context) { |
| var inst, list = components[Ctor.name]; |
| if (Ctor.prototype && Ctor.prototype.render) { |
| inst = new Ctor(props, context); |
| Component.call(inst, props, context); |
| } else { |
| inst = new Component(props, context); |
| inst.constructor = Ctor; |
| inst.render = doRender; |
| } |
| if (list) for (var i = list.length; i--; ) if (list[i].constructor === Ctor) { |
| inst.__b = list[i].__b; |
| list.splice(i, 1); |
| break; |
| } |
| return inst; |
| } |
| function doRender(props, state, context) { |
| return this.constructor(props, context); |
| } |
| function setComponentProps(component, props, opts, context, mountAll) { |
| if (!component.__x) { |
| component.__x = !0; |
| if (component.__r = props.ref) delete props.ref; |
| if (component.__k = props.key) delete props.key; |
| if (!component.base || mountAll) { |
| if (component.componentWillMount) component.componentWillMount(); |
| } else if (component.componentWillReceiveProps) component.componentWillReceiveProps(props, context); |
| if (context && context !== component.context) { |
| if (!component.__c) component.__c = component.context; |
| component.context = context; |
| } |
| if (!component.__p) component.__p = component.props; |
| component.props = props; |
| component.__x = !1; |
| if (0 !== opts) if (1 === opts || !1 !== options.syncComponentUpdates || !component.base) renderComponent(component, 1, mountAll); else enqueueRender(component); |
| if (component.__r) component.__r(component); |
| } |
| } |
| function renderComponent(component, opts, mountAll, isChild) { |
| if (!component.__x) { |
| var rendered, inst, cbase, props = component.props, state = component.state, context = component.context, previousProps = component.__p || props, previousState = component.__s || state, previousContext = component.__c || context, isUpdate = component.base, nextBase = component.__b, initialBase = isUpdate || nextBase, initialChildComponent = component._component, skip = !1; |
| if (isUpdate) { |
| component.props = previousProps; |
| component.state = previousState; |
| component.context = previousContext; |
| if (2 !== opts && component.shouldComponentUpdate && !1 === component.shouldComponentUpdate(props, state, context)) skip = !0; else if (component.componentWillUpdate) component.componentWillUpdate(props, state, context); |
| component.props = props; |
| component.state = state; |
| component.context = context; |
| } |
| component.__p = component.__s = component.__c = component.__b = null; |
| component.__d = !1; |
| if (!skip) { |
| rendered = component.render(props, state, context); |
| if (component.getChildContext) context = extend(extend({}, context), component.getChildContext()); |
| var toUnmount, base, childComponent = rendered && rendered.nodeName; |
| if ('function' == typeof childComponent) { |
| var childProps = getNodeProps(rendered); |
| inst = initialChildComponent; |
| if (inst && inst.constructor === childComponent && childProps.key == inst.__k) setComponentProps(inst, childProps, 1, context, !1); else { |
| toUnmount = inst; |
| component._component = inst = createComponent(childComponent, childProps, context); |
| inst.__b = inst.__b || nextBase; |
| inst.__u = component; |
| setComponentProps(inst, childProps, 0, context, !1); |
| renderComponent(inst, 1, mountAll, !0); |
| } |
| base = inst.base; |
| } else { |
| cbase = initialBase; |
| toUnmount = initialChildComponent; |
| if (toUnmount) cbase = component._component = null; |
| if (initialBase || 1 === opts) { |
| if (cbase) cbase._component = null; |
| base = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, !0); |
| } |
| } |
| if (initialBase && base !== initialBase && inst !== initialChildComponent) { |
| var baseParent = initialBase.parentNode; |
| if (baseParent && base !== baseParent) { |
| baseParent.replaceChild(base, initialBase); |
| if (!toUnmount) { |
| initialBase._component = null; |
| recollectNodeTree(initialBase, !1); |
| } |
| } |
| } |
| if (toUnmount) unmountComponent(toUnmount); |
| component.base = base; |
| if (base && !isChild) { |
| var componentRef = component, t = component; |
| while (t = t.__u) (componentRef = t).base = base; |
| base._component = componentRef; |
| base._componentConstructor = componentRef.constructor; |
| } |
| } |
| if (!isUpdate || mountAll) mounts.unshift(component); else if (!skip) { |
| if (component.componentDidUpdate) component.componentDidUpdate(previousProps, previousState, previousContext); |
| if (options.afterUpdate) options.afterUpdate(component); |
| } |
| if (null != component.__h) while (component.__h.length) component.__h.pop().call(component); |
| if (!diffLevel && !isChild) flushMounts(); |
| } |
| } |
| function buildComponentFromVNode(dom, vnode, context, mountAll) { |
| var c = dom && dom._component, originalComponent = c, oldDom = dom, isDirectOwner = c && dom._componentConstructor === vnode.nodeName, isOwner = isDirectOwner, props = getNodeProps(vnode); |
| while (c && !isOwner && (c = c.__u)) isOwner = c.constructor === vnode.nodeName; |
| if (c && isOwner && (!mountAll || c._component)) { |
| setComponentProps(c, props, 3, context, mountAll); |
| dom = c.base; |
| } else { |
| if (originalComponent && !isDirectOwner) { |
| unmountComponent(originalComponent); |
| dom = oldDom = null; |
| } |
| c = createComponent(vnode.nodeName, props, context); |
| if (dom && !c.__b) { |
| c.__b = dom; |
| oldDom = null; |
| } |
| setComponentProps(c, props, 1, context, mountAll); |
| dom = c.base; |
| if (oldDom && dom !== oldDom) { |
| oldDom._component = null; |
| recollectNodeTree(oldDom, !1); |
| } |
| } |
| return dom; |
| } |
| function unmountComponent(component) { |
| if (options.beforeUnmount) options.beforeUnmount(component); |
| var base = component.base; |
| component.__x = !0; |
| if (component.componentWillUnmount) component.componentWillUnmount(); |
| component.base = null; |
| var inner = component._component; |
| if (inner) unmountComponent(inner); else if (base) { |
| if (base.__preactattr_ && base.__preactattr_.ref) base.__preactattr_.ref(null); |
| component.__b = base; |
| removeNode(base); |
| collectComponent(component); |
| removeChildren(base); |
| } |
| if (component.__r) component.__r(null); |
| } |
| function Component(props, context) { |
| this.__d = !0; |
| this.context = context; |
| this.props = props; |
| this.state = this.state || {}; |
| } |
| function render(vnode, parent, merge) { |
| return diff(merge, vnode, {}, !1, parent, !1); |
| } |
| var options = {}; |
| var stack = []; |
| var EMPTY_CHILDREN = []; |
| var defer = 'function' == typeof Promise ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout; |
| var IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i; |
| var items = []; |
| var mounts = []; |
| var diffLevel = 0; |
| var isSvgMode = !1; |
| var hydrating = !1; |
| var components = {}; |
| extend(Component.prototype, { |
| setState: function(state, callback) { |
| var s = this.state; |
| if (!this.__s) this.__s = extend({}, s); |
| extend(s, 'function' == typeof state ? state(s, this.props) : state); |
| if (callback) (this.__h = this.__h || []).push(callback); |
| enqueueRender(this); |
| }, |
| forceUpdate: function(callback) { |
| if (callback) (this.__h = this.__h || []).push(callback); |
| renderComponent(this, 2); |
| }, |
| render: function() {} |
| }); |
| var preact = { |
| h: h, |
| createElement: h, |
| cloneElement: cloneElement, |
| Component: Component, |
| render: render, |
| rerender: rerender, |
| options: options |
| }; |
| if ('undefined' != typeof module) module.exports = preact; else self.preact = preact; |
| }(); |
| //# sourceMappingURL=preact.js.map |
