for example), or a DocumentFragment 1579 | * instance, depending on the contents of the `html` string. 1580 | * 1581 | * @param {String} html - HTML string to "domify" 1582 | * @param {Document} doc - The `document` instance to create the Node for 1583 | * @return {DOMNode} the TextNode, DOM Node, or DocumentFragment instance 1584 | * @api private 1585 | */ 1586 | 1587 | function parse(html, doc) { 1588 | if ('string' != typeof html) throw new TypeError('String expected'); 1589 | 1590 | // default to the global `document` object 1591 | if (!doc) doc = document; 1592 | 1593 | // tag name 1594 | var m = /<([\w:]+)/.exec(html); 1595 | if (!m) return doc.createTextNode(html); 1596 | 1597 | html = html.replace(/^\s+|\s+$/g, ''); // Remove leading/trailing whitespace 1598 | 1599 | var tag = m[1]; 1600 | 1601 | // body support 1602 | if (tag == 'body') { 1603 | var el = doc.createElement('html'); 1604 | el.innerHTML = html; 1605 | return el.removeChild(el.lastChild); 1606 | } 1607 | 1608 | // wrap map 1609 | var wrap = map[tag] || map._default; 1610 | var depth = wrap[0]; 1611 | var prefix = wrap[1]; 1612 | var suffix = wrap[2]; 1613 | var el = doc.createElement('div'); 1614 | el.innerHTML = prefix + html + suffix; 1615 | while (depth--) el = el.lastChild; 1616 | 1617 | // one element 1618 | if (el.firstChild == el.lastChild) { 1619 | return el.removeChild(el.firstChild); 1620 | } 1621 | 1622 | // several elements 1623 | var fragment = doc.createDocumentFragment(); 1624 | while (el.firstChild) { 1625 | fragment.appendChild(el.removeChild(el.firstChild)); 1626 | } 1627 | 1628 | return fragment; 1629 | } 1630 | 1631 | },{}],22:[function(require,module,exports){ 1632 | 1633 | module.exports = inserted; 1634 | 1635 | /** 1636 | * Watch for removal with a DOM3 Mutation Event. 1637 | * 1638 | * @param {Element} el 1639 | * @param {Function} fn 1640 | * @api private 1641 | */ 1642 | 1643 | function inserted(el, fn) { 1644 | function cb(mutationEvent) { 1645 | var target = mutationEvent.target 1646 | , children = target.getElementsByTagName ? [].slice.call(target.getElementsByTagName('*')) : []; 1647 | 1648 | if (el === target || ~children.indexOf(el)) { 1649 | fn(el); 1650 | document.removeEventListener('DOMNodeInserted', cb); 1651 | } 1652 | } 1653 | 1654 | document.addEventListener('DOMNodeInserted', cb); 1655 | } 1656 | 1657 | },{}],23:[function(require,module,exports){ 1658 | 1659 | /** 1660 | * Module dependencies. 1661 | */ 1662 | 1663 | var withinDoc = require('within-document') 1664 | , Observer = require('mutation-observer'); 1665 | 1666 | /** 1667 | * Expose `inserted`. 1668 | */ 1669 | 1670 | module.exports = inserted; 1671 | 1672 | /** 1673 | * Watched elements. 1674 | * 1675 | * @api private 1676 | */ 1677 | 1678 | var watched = []; 1679 | 1680 | /** 1681 | * Set up observer. 1682 | * 1683 | * @api private 1684 | */ 1685 | 1686 | var observer = new Observer(onchanges); 1687 | 1688 | /** 1689 | * Generic observer callback. 1690 | * 1691 | * @api private 1692 | */ 1693 | 1694 | function onchanges(changes){ 1695 | // keep track of number of found els 1696 | var found = 0; 1697 | 1698 | for (var i = 0, l = changes.length; i < l; i++) { 1699 | if (changes[i].addedNodes.length) { 1700 | // allow for manipulation of `watched` 1701 | // from within the callback 1702 | var w = watched.slice(); 1703 | 1704 | for (var i2 = 0, l2 = w.length; i2 < l2; i2++) { 1705 | var el = w[i2][0]; 1706 | 1707 | // check if the added element is the same 1708 | // or that it's now part of the document 1709 | if (withinDoc(el)) { 1710 | watched.splice(i2 - found++, 1)[0][1](); 1711 | 1712 | // abort if nothing else left to watch 1713 | if (!watched.length) observer.disconnect(); 1714 | } 1715 | } 1716 | 1717 | // we only need to loop through watched els once 1718 | break; 1719 | } 1720 | } 1721 | } 1722 | 1723 | /** 1724 | * Starts observing the DOM. 1725 | * 1726 | * @api private 1727 | */ 1728 | 1729 | function observe(){ 1730 | var html = document.documentElement; 1731 | observer.observe(html, { 1732 | subtree: true, 1733 | childList: true 1734 | }); 1735 | } 1736 | 1737 | /** 1738 | * Watches for insertion of `el` into DOM. 1739 | * 1740 | * @param {Element} el 1741 | * @param {Function} fn 1742 | * @api private 1743 | */ 1744 | 1745 | function inserted(el, fn){ 1746 | // reattach observer if we weren't watching 1747 | if (!watched.length) observe(); 1748 | 1749 | // we add it to the list of elements to check 1750 | watched.push([el, fn]); 1751 | } 1752 | 1753 | },{"mutation-observer":26,"within-document":30}],24:[function(require,module,exports){ 1754 | 1755 | /** 1756 | * Module dependencies. 1757 | */ 1758 | 1759 | var withinDocument = require('within-document'); 1760 | 1761 | /** 1762 | * Expose `inserted`. 1763 | */ 1764 | 1765 | exports = module.exports = inserted; 1766 | 1767 | /** 1768 | * Default interval. 1769 | */ 1770 | 1771 | exports.interval = 200; 1772 | 1773 | /** 1774 | * Watch for removal and invoke `fn(el)`. 1775 | * 1776 | * @param {Element} el 1777 | * @param {Function} fn 1778 | * @api public 1779 | */ 1780 | 1781 | function inserted(el, fn){ 1782 | interval(el, fn); 1783 | } 1784 | 1785 | /** 1786 | * Watch for removal with an interval. 1787 | * 1788 | * @param {Element} el 1789 | * @param {Function} fn 1790 | * @api private 1791 | */ 1792 | 1793 | function interval(el, fn) { 1794 | var id = setInterval(function(){ 1795 | if (!withinDocument(el)) return; 1796 | clearInterval(id); 1797 | fn(el); 1798 | }, exports.interval); 1799 | } 1800 | 1801 | },{"within-document":30}],25:[function(require,module,exports){ 1802 | 1803 | /** 1804 | * Module dependencies. 1805 | */ 1806 | 1807 | var Observer = require('mutation-observer'); 1808 | 1809 | /** 1810 | * Exports the `MutationObserver` based approach 1811 | * or the fallback one depending on UA capabilities. 1812 | */ 1813 | 1814 | module.exports = Observer 1815 | ? require('./dom4') 1816 | : document.addEventListener 1817 | ? require('./dom3') 1818 | : require('./fallback'); 1819 | 1820 | },{"./dom3":22,"./dom4":23,"./fallback":24,"mutation-observer":26}],26:[function(require,module,exports){ 1821 | var MutationObserver = window.MutationObserver 1822 | || window.WebKitMutationObserver 1823 | || window.MozMutationObserver; 1824 | 1825 | /* 1826 | * Copyright 2012 The Polymer Authors. All rights reserved. 1827 | * Use of this source code is goverened by a BSD-style 1828 | * license that can be found in the LICENSE file. 1829 | */ 1830 | 1831 | var WeakMap = window.WeakMap; 1832 | 1833 | if (typeof WeakMap === 'undefined') { 1834 | var defineProperty = Object.defineProperty; 1835 | var counter = Date.now() % 1e9; 1836 | 1837 | WeakMap = function() { 1838 | this.name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__'); 1839 | }; 1840 | 1841 | WeakMap.prototype = { 1842 | set: function(key, value) { 1843 | var entry = key[this.name]; 1844 | if (entry && entry[0] === key) 1845 | entry[1] = value; 1846 | else 1847 | defineProperty(key, this.name, {value: [key, value], writable: true}); 1848 | return this; 1849 | }, 1850 | get: function(key) { 1851 | var entry; 1852 | return (entry = key[this.name]) && entry[0] === key ? 1853 | entry[1] : undefined; 1854 | }, 1855 | 'delete': function(key) { 1856 | var entry = key[this.name]; 1857 | if (!entry) return false; 1858 | var hasValue = entry[0] === key; 1859 | entry[0] = entry[1] = undefined; 1860 | return hasValue; 1861 | }, 1862 | has: function(key) { 1863 | var entry = key[this.name]; 1864 | if (!entry) return false; 1865 | return entry[0] === key; 1866 | } 1867 | }; 1868 | } 1869 | 1870 | var registrationsTable = new WeakMap(); 1871 | 1872 | // We use setImmediate or postMessage for our future callback. 1873 | var setImmediate = window.msSetImmediate; 1874 | 1875 | // Use post message to emulate setImmediate. 1876 | if (!setImmediate) { 1877 | var setImmediateQueue = []; 1878 | var sentinel = String(Math.random()); 1879 | window.addEventListener('message', function(e) { 1880 | if (e.data === sentinel) { 1881 | var queue = setImmediateQueue; 1882 | setImmediateQueue = []; 1883 | queue.forEach(function(func) { 1884 | func(); 1885 | }); 1886 | } 1887 | }); 1888 | setImmediate = function(func) { 1889 | setImmediateQueue.push(func); 1890 | window.postMessage(sentinel, '*'); 1891 | }; 1892 | } 1893 | 1894 | // This is used to ensure that we never schedule 2 callas to setImmediate 1895 | var isScheduled = false; 1896 | 1897 | // Keep track of observers that needs to be notified next time. 1898 | var scheduledObservers = []; 1899 | 1900 | /** 1901 | * Schedules |dispatchCallback| to be called in the future. 1902 | * @param {MutationObserver} observer 1903 | */ 1904 | function scheduleCallback(observer) { 1905 | scheduledObservers.push(observer); 1906 | if (!isScheduled) { 1907 | isScheduled = true; 1908 | setImmediate(dispatchCallbacks); 1909 | } 1910 | } 1911 | 1912 | function wrapIfNeeded(node) { 1913 | return window.ShadowDOMPolyfill && 1914 | window.ShadowDOMPolyfill.wrapIfNeeded(node) || 1915 | node; 1916 | } 1917 | 1918 | function dispatchCallbacks() { 1919 | // http://dom.spec.whatwg.org/#mutation-observers 1920 | 1921 | isScheduled = false; // Used to allow a new setImmediate call above. 1922 | 1923 | var observers = scheduledObservers; 1924 | scheduledObservers = []; 1925 | // Sort observers based on their creation UID (incremental). 1926 | observers.sort(function(o1, o2) { 1927 | return o1.uid_ - o2.uid_; 1928 | }); 1929 | 1930 | var anyNonEmpty = false; 1931 | observers.forEach(function(observer) { 1932 | 1933 | // 2.1, 2.2 1934 | var queue = observer.takeRecords(); 1935 | // 2.3. Remove all transient registered observers whose observer is mo. 1936 | removeTransientObserversFor(observer); 1937 | 1938 | // 2.4 1939 | if (queue.length) { 1940 | observer.callback_(queue, observer); 1941 | anyNonEmpty = true; 1942 | } 1943 | }); 1944 | 1945 | // 3. 1946 | if (anyNonEmpty) 1947 | dispatchCallbacks(); 1948 | } 1949 | 1950 | function removeTransientObserversFor(observer) { 1951 | observer.nodes_.forEach(function(node) { 1952 | var registrations = registrationsTable.get(node); 1953 | if (!registrations) 1954 | return; 1955 | registrations.forEach(function(registration) { 1956 | if (registration.observer === observer) 1957 | registration.removeTransientObservers(); 1958 | }); 1959 | }); 1960 | } 1961 | 1962 | /** 1963 | * This function is used for the "For each registered observer observer (with 1964 | * observer's options as options) in target's list of registered observers, 1965 | * run these substeps:" and the "For each ancestor ancestor of target, and for 1966 | * each registered observer observer (with options options) in ancestor's list 1967 | * of registered observers, run these substeps:" part of the algorithms. The 1968 | * |options.subtree| is checked to ensure that the callback is called 1969 | * correctly. 1970 | * 1971 | * @param {Node} target 1972 | * @param {function(MutationObserverInit):MutationRecord} callback 1973 | */ 1974 | function forEachAncestorAndObserverEnqueueRecord(target, callback) { 1975 | for (var node = target; node; node = node.parentNode) { 1976 | var registrations = registrationsTable.get(node); 1977 | 1978 | if (registrations) { 1979 | for (var j = 0; j < registrations.length; j++) { 1980 | var registration = registrations[j]; 1981 | var options = registration.options; 1982 | 1983 | // Only target ignores subtree. 1984 | if (node !== target && !options.subtree) 1985 | continue; 1986 | 1987 | var record = callback(options); 1988 | if (record) 1989 | registration.enqueue(record); 1990 | } 1991 | } 1992 | } 1993 | } 1994 | 1995 | var uidCounter = 0; 1996 | 1997 | /** 1998 | * The class that maps to the DOM MutationObserver interface. 1999 | * @param {Function} callback. 2000 | * @constructor 2001 | */ 2002 | function JsMutationObserver(callback) { 2003 | this.callback_ = callback; 2004 | this.nodes_ = []; 2005 | this.records_ = []; 2006 | this.uid_ = ++uidCounter; 2007 | } 2008 | 2009 | JsMutationObserver.prototype = { 2010 | observe: function(target, options) { 2011 | target = wrapIfNeeded(target); 2012 | 2013 | // 1.1 2014 | if (!options.childList && !options.attributes && !options.characterData || 2015 | 2016 | // 1.2 2017 | options.attributeOldValue && !options.attributes || 2018 | 2019 | // 1.3 2020 | options.attributeFilter && options.attributeFilter.length && 2021 | !options.attributes || 2022 | 2023 | // 1.4 2024 | options.characterDataOldValue && !options.characterData) { 2025 | 2026 | throw new SyntaxError(); 2027 | } 2028 | 2029 | var registrations = registrationsTable.get(target); 2030 | if (!registrations) 2031 | registrationsTable.set(target, registrations = []); 2032 | 2033 | // 2 2034 | // If target's list of registered observers already includes a registered 2035 | // observer associated with the context object, replace that registered 2036 | // observer's options with options. 2037 | var registration; 2038 | for (var i = 0; i < registrations.length; i++) { 2039 | if (registrations[i].observer === this) { 2040 | registration = registrations[i]; 2041 | registration.removeListeners(); 2042 | registration.options = options; 2043 | break; 2044 | } 2045 | } 2046 | 2047 | // 3. 2048 | // Otherwise, add a new registered observer to target's list of registered 2049 | // observers with the context object as the observer and options as the 2050 | // options, and add target to context object's list of nodes on which it 2051 | // is registered. 2052 | if (!registration) { 2053 | registration = new Registration(this, target, options); 2054 | registrations.push(registration); 2055 | this.nodes_.push(target); 2056 | } 2057 | 2058 | registration.addListeners(); 2059 | }, 2060 | 2061 | disconnect: function() { 2062 | this.nodes_.forEach(function(node) { 2063 | var registrations = registrationsTable.get(node); 2064 | for (var i = 0; i < registrations.length; i++) { 2065 | var registration = registrations[i]; 2066 | if (registration.observer === this) { 2067 | registration.removeListeners(); 2068 | registrations.splice(i, 1); 2069 | // Each node can only have one registered observer associated with 2070 | // this observer. 2071 | break; 2072 | } 2073 | } 2074 | }, this); 2075 | this.records_ = []; 2076 | }, 2077 | 2078 | takeRecords: function() { 2079 | var copyOfRecords = this.records_; 2080 | this.records_ = []; 2081 | return copyOfRecords; 2082 | } 2083 | }; 2084 | 2085 | /** 2086 | * @param {string} type 2087 | * @param {Node} target 2088 | * @constructor 2089 | */ 2090 | function MutationRecord(type, target) { 2091 | this.type = type; 2092 | this.target = target; 2093 | this.addedNodes = []; 2094 | this.removedNodes = []; 2095 | this.previousSibling = null; 2096 | this.nextSibling = null; 2097 | this.attributeName = null; 2098 | this.attributeNamespace = null; 2099 | this.oldValue = null; 2100 | } 2101 | 2102 | function copyMutationRecord(original) { 2103 | var record = new MutationRecord(original.type, original.target); 2104 | record.addedNodes = original.addedNodes.slice(); 2105 | record.removedNodes = original.removedNodes.slice(); 2106 | record.previousSibling = original.previousSibling; 2107 | record.nextSibling = original.nextSibling; 2108 | record.attributeName = original.attributeName; 2109 | record.attributeNamespace = original.attributeNamespace; 2110 | record.oldValue = original.oldValue; 2111 | return record; 2112 | }; 2113 | 2114 | // We keep track of the two (possibly one) records used in a single mutation. 2115 | var currentRecord, recordWithOldValue; 2116 | 2117 | /** 2118 | * Creates a record without |oldValue| and caches it as |currentRecord| for 2119 | * later use. 2120 | * @param {string} oldValue 2121 | * @return {MutationRecord} 2122 | */ 2123 | function getRecord(type, target) { 2124 | return currentRecord = new MutationRecord(type, target); 2125 | } 2126 | 2127 | /** 2128 | * Gets or creates a record with |oldValue| based in the |currentRecord| 2129 | * @param {string} oldValue 2130 | * @return {MutationRecord} 2131 | */ 2132 | function getRecordWithOldValue(oldValue) { 2133 | if (recordWithOldValue) 2134 | return recordWithOldValue; 2135 | recordWithOldValue = copyMutationRecord(currentRecord); 2136 | recordWithOldValue.oldValue = oldValue; 2137 | return recordWithOldValue; 2138 | } 2139 | 2140 | function clearRecords() { 2141 | currentRecord = recordWithOldValue = undefined; 2142 | } 2143 | 2144 | /** 2145 | * @param {MutationRecord} record 2146 | * @return {boolean} Whether the record represents a record from the current 2147 | * mutation event. 2148 | */ 2149 | function recordRepresentsCurrentMutation(record) { 2150 | return record === recordWithOldValue || record === currentRecord; 2151 | } 2152 | 2153 | /** 2154 | * Selects which record, if any, to replace the last record in the queue. 2155 | * This returns |null| if no record should be replaced. 2156 | * 2157 | * @param {MutationRecord} lastRecord 2158 | * @param {MutationRecord} newRecord 2159 | * @param {MutationRecord} 2160 | */ 2161 | function selectRecord(lastRecord, newRecord) { 2162 | if (lastRecord === newRecord) 2163 | return lastRecord; 2164 | 2165 | // Check if the the record we are adding represents the same record. If 2166 | // so, we keep the one with the oldValue in it. 2167 | if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) 2168 | return recordWithOldValue; 2169 | 2170 | return null; 2171 | } 2172 | 2173 | /** 2174 | * Class used to represent a registered observer. 2175 | * @param {MutationObserver} observer 2176 | * @param {Node} target 2177 | * @param {MutationObserverInit} options 2178 | * @constructor 2179 | */ 2180 | function Registration(observer, target, options) { 2181 | this.observer = observer; 2182 | this.target = target; 2183 | this.options = options; 2184 | this.transientObservedNodes = []; 2185 | } 2186 | 2187 | Registration.prototype = { 2188 | enqueue: function(record) { 2189 | var records = this.observer.records_; 2190 | var length = records.length; 2191 | 2192 | // There are cases where we replace the last record with the new record. 2193 | // For example if the record represents the same mutation we need to use 2194 | // the one with the oldValue. If we get same record (this can happen as we 2195 | // walk up the tree) we ignore the new record. 2196 | if (records.length > 0) { 2197 | var lastRecord = records[length - 1]; 2198 | var recordToReplaceLast = selectRecord(lastRecord, record); 2199 | if (recordToReplaceLast) { 2200 | records[length - 1] = recordToReplaceLast; 2201 | return; 2202 | } 2203 | } else { 2204 | scheduleCallback(this.observer); 2205 | } 2206 | 2207 | records[length] = record; 2208 | }, 2209 | 2210 | addListeners: function() { 2211 | this.addListeners_(this.target); 2212 | }, 2213 | 2214 | addListeners_: function(node) { 2215 | var options = this.options; 2216 | if (options.attributes) 2217 | node.addEventListener('DOMAttrModified', this, true); 2218 | 2219 | if (options.characterData) 2220 | node.addEventListener('DOMCharacterDataModified', this, true); 2221 | 2222 | if (options.childList) 2223 | node.addEventListener('DOMNodeInserted', this, true); 2224 | 2225 | if (options.childList || options.subtree) 2226 | node.addEventListener('DOMNodeRemoved', this, true); 2227 | }, 2228 | 2229 | removeListeners: function() { 2230 | this.removeListeners_(this.target); 2231 | }, 2232 | 2233 | removeListeners_: function(node) { 2234 | var options = this.options; 2235 | if (options.attributes) 2236 | node.removeEventListener('DOMAttrModified', this, true); 2237 | 2238 | if (options.characterData) 2239 | node.removeEventListener('DOMCharacterDataModified', this, true); 2240 | 2241 | if (options.childList) 2242 | node.removeEventListener('DOMNodeInserted', this, true); 2243 | 2244 | if (options.childList || options.subtree) 2245 | node.removeEventListener('DOMNodeRemoved', this, true); 2246 | }, 2247 | 2248 | /** 2249 | * Adds a transient observer on node. The transient observer gets removed 2250 | * next time we deliver the change records. 2251 | * @param {Node} node 2252 | */ 2253 | addTransientObserver: function(node) { 2254 | // Don't add transient observers on the target itself. We already have all 2255 | // the required listeners set up on the target. 2256 | if (node === this.target) 2257 | return; 2258 | 2259 | this.addListeners_(node); 2260 | this.transientObservedNodes.push(node); 2261 | var registrations = registrationsTable.get(node); 2262 | if (!registrations) 2263 | registrationsTable.set(node, registrations = []); 2264 | 2265 | // We know that registrations does not contain this because we already 2266 | // checked if node === this.target. 2267 | registrations.push(this); 2268 | }, 2269 | 2270 | removeTransientObservers: function() { 2271 | var transientObservedNodes = this.transientObservedNodes; 2272 | this.transientObservedNodes = []; 2273 | 2274 | transientObservedNodes.forEach(function(node) { 2275 | // Transient observers are never added to the target. 2276 | this.removeListeners_(node); 2277 | 2278 | var registrations = registrationsTable.get(node); 2279 | for (var i = 0; i < registrations.length; i++) { 2280 | if (registrations[i] === this) { 2281 | registrations.splice(i, 1); 2282 | // Each node can only have one registered observer associated with 2283 | // this observer. 2284 | break; 2285 | } 2286 | } 2287 | }, this); 2288 | }, 2289 | 2290 | handleEvent: function(e) { 2291 | // Stop propagation since we are managing the propagation manually. 2292 | // This means that other mutation events on the page will not work 2293 | // correctly but that is by design. 2294 | e.stopImmediatePropagation(); 2295 | 2296 | switch (e.type) { 2297 | case 'DOMAttrModified': 2298 | // http://dom.spec.whatwg.org/#concept-mo-queue-attributes 2299 | 2300 | var name = e.attrName; 2301 | var namespace = e.relatedNode.namespaceURI; 2302 | var target = e.target; 2303 | 2304 | // 1. 2305 | var record = new getRecord('attributes', target); 2306 | record.attributeName = name; 2307 | record.attributeNamespace = namespace; 2308 | 2309 | // 2. 2310 | var oldValue = 2311 | e.attrChange === MutationEvent.ADDITION ? null : e.prevValue; 2312 | 2313 | forEachAncestorAndObserverEnqueueRecord(target, function(options) { 2314 | // 3.1, 4.2 2315 | if (!options.attributes) 2316 | return; 2317 | 2318 | // 3.2, 4.3 2319 | if (options.attributeFilter && options.attributeFilter.length && 2320 | options.attributeFilter.indexOf(name) === -1 && 2321 | options.attributeFilter.indexOf(namespace) === -1) { 2322 | return; 2323 | } 2324 | // 3.3, 4.4 2325 | if (options.attributeOldValue) 2326 | return getRecordWithOldValue(oldValue); 2327 | 2328 | // 3.4, 4.5 2329 | return record; 2330 | }); 2331 | 2332 | break; 2333 | 2334 | case 'DOMCharacterDataModified': 2335 | // http://dom.spec.whatwg.org/#concept-mo-queue-characterdata 2336 | var target = e.target; 2337 | 2338 | // 1. 2339 | var record = getRecord('characterData', target); 2340 | 2341 | // 2. 2342 | var oldValue = e.prevValue; 2343 | 2344 | 2345 | forEachAncestorAndObserverEnqueueRecord(target, function(options) { 2346 | // 3.1, 4.2 2347 | if (!options.characterData) 2348 | return; 2349 | 2350 | // 3.2, 4.3 2351 | if (options.characterDataOldValue) 2352 | return getRecordWithOldValue(oldValue); 2353 | 2354 | // 3.3, 4.4 2355 | return record; 2356 | }); 2357 | 2358 | break; 2359 | 2360 | case 'DOMNodeRemoved': 2361 | this.addTransientObserver(e.target); 2362 | // Fall through. 2363 | case 'DOMNodeInserted': 2364 | // http://dom.spec.whatwg.org/#concept-mo-queue-childlist 2365 | var target = e.relatedNode; 2366 | var changedNode = e.target; 2367 | var addedNodes, removedNodes; 2368 | if (e.type === 'DOMNodeInserted') { 2369 | addedNodes = [changedNode]; 2370 | removedNodes = []; 2371 | } else { 2372 | 2373 | addedNodes = []; 2374 | removedNodes = [changedNode]; 2375 | } 2376 | var previousSibling = changedNode.previousSibling; 2377 | var nextSibling = changedNode.nextSibling; 2378 | 2379 | // 1. 2380 | var record = getRecord('childList', target); 2381 | record.addedNodes = addedNodes; 2382 | record.removedNodes = removedNodes; 2383 | record.previousSibling = previousSibling; 2384 | record.nextSibling = nextSibling; 2385 | 2386 | forEachAncestorAndObserverEnqueueRecord(target, function(options) { 2387 | // 2.1, 3.2 2388 | if (!options.childList) 2389 | return; 2390 | 2391 | // 2.2, 3.3 2392 | return record; 2393 | }); 2394 | 2395 | } 2396 | 2397 | clearRecords(); 2398 | } 2399 | }; 2400 | 2401 | if (!MutationObserver) { 2402 | MutationObserver = JsMutationObserver; 2403 | } 2404 | 2405 | module.exports = MutationObserver; 2406 | 2407 | },{}],27:[function(require,module,exports){ 2408 | 2409 | /** 2410 | * Module exports. 2411 | */ 2412 | 2413 | module.exports = loadStyles; 2414 | 2415 | /** 2416 | * Injects the CSS into the DOM node. 2417 | * 2418 | * @param {String} css CSS string to add to the