{"version":3,"sources":["../src/util.js","../src/h.js","../src/vdom/index.js","../src/extend.js","../src/dom/index.js","../src/vdom/diff.js","../src/we-element.js","../src/render.js","../src/define.js","../src/clone-element.js","../src/get-host.js","../src/class.js","../node_modules/_construct-style-sheets-polyfill@3.0.0-0@construct-style-sheets-polyfill/dist/adoptedStyleSheets.js","../src/options.js","../src/o.js","../src/omi.js"],"names":["cssToDom","css","node","document","createElement","textContent","camelCase","str","replace","$","$1","toUpperCase","Fragment","props","children","extend","obj","i","applyRef","ref","value","current","isArray","Object","prototype","toString","call","pathToArr","path","split","hyphenate","hyphenateRE","toLowerCase","getValByPath","forEach","prop","h","nodeName","attributes","lastSimple","child","simple","arguments","length","stack","push","pop","String","p","key","options","vnode","isSameNodeType","splitText","mapping","hydrating","_componentConstructor","isNamedNode","extend$1","name","handler","extension","origin","arr","get","e","type","eventProxy","el","_listeners","addEventListener","createNode","removeNode","setAccessor","component","old","isSvg","style","cssText","IS_NON_DIMENSIONAL","test","constructor","is","bindEvent","innerHTML","pureRemoveAttribute","removeAttribute","ns","removeAttributeNS","pureSetAttribute","setAttribute","className","useCapture","event","nameLower","eventProxy$1","ret","diffLevel","isSvgMode","parent","ownerSVGElement","dom","innerDiffNode","updateSelf","item","index","ele","one","idiff","recollectNodeTree","parentNode","appendChild","out","nodeValue","createTextNode","replaceChild","vnodeName","prevProps","vchildren","firstChild","fc","a","nextSibling","noSlot","dangerouslySetInnerHTML","diffAttributes","min","len","childrenLen","vlen","j","keyedLen","originalChildren","keyed","vchild","_child","_component","__key","trim","isHydrating","c","f","unmountOnly","ATTR_KEY","removeChildren","oldClone","assign","receiveProps","isWeElement","attrs","ccName","indexOf","_ccName","_classCallCheck","instance","Constructor","TypeError","_possibleConstructorReturn","self","ReferenceError","HTMLElement","WeElement","_classCallCheck$1","_possibleConstructorReturn$1","define","ctor","customElements","config","Ele","_WeElement","_temp","_this","_ret","_len","args","Array","this","apply","concat","compute","propTypes","defaultProps","isLightDom","storeHelpers","func","target","cloneElement","getHost","shadowRoot","host","rpx","b","window","innerWidth","arg","classNames","classes","argType","inner","join","_Array$prototype$slic","slice","class","unshift","o","JSON","stringify","createRef","store","root","global","Math","Reflect","hasOwnProperty","BuiltInHTMLElement","construct","setPrototypeOf","Promise","resolve","then","bind","setTimeout","_HTMLElement","elementId","id","computed","isInstalled","connectedCallback","attrsToProps","beforeInstall","install","afterInstall","attachShadow","mode","removeChild","adoptedStyleSheets","styleSheet","replaceSync","adoptedStyleSheet","styleSheets","_customStyleContent","_customStyleElement","rootNode","installed","disconnectedCallback","uninstall","update","ignoreAttrs","beforeUpdate","_willUpdate","beforeRender","rendered","forceUpdate","updated","_this2","updateProps","val","getAttribute","Number","Boolean","substr","Omi","parse","fire","data","dispatchEvent","CustomEvent","detail","_contents","contents","importPattern","console","warn","clearRules","sheet","cssRules","deleteRule","insertAllRules","from","to","rule","insertRule","isElementConnected","element","isConnected","contains","unique","filter","diff","arr1","arr2","getShadowRoot","closedShadowRootRegistry","isCSSStyleSheetInstance","proto$2","isPrototypeOf","nonConstructedProto","isNonConstructedStyleSheetInstance","addAdopterLocation","location","adopter","$adoptersByLocation","set","$locations","getAdopterByLocation","removeAdopterLocation","delete","_location","restyleAdopter","requestAnimationFrame","$basicStyleSheet","checkInvocationCorrectness","has","ConstructedStyleSheet","bootstrapper","body","WeakMap","getAssociatedLocation","locations","Location","attachAdoptedStyleSheetProperty","defineProperty","configurable","enumerable","sheets","traverseWebComponents","callback","iter","createNodeIterator","NodeFilter","SHOW_ELEMENT","foundNode","FILTER_ACCEPT","FILTER_REJECT","next","nextNode","isExistingAdopter","HTMLStyleElement","$uniqueSheets","some","getAdopterContainer","$element","Document","adopt","styleList","createDocumentFragment","observer","$observer","container","disconnect","insertBefore","observe","defaultObserverOptions","MutationObserver","mutations","mutation","hasShadyCss","addedNodes","Element","connect","removedNodes","ShadyCSS","nativeShadow","implementation","createHTMLDocument","cssStyleSheetMethods","NonConstructedStyleSheet","CSSStyleSheet","reject","_DOMException","self_1","ownerNode","rejectImports","method","basic","result","Symbol","hasInstance","childList","subtree","proto$1","readyState","locationType","every","oldUniqueSheets","uniqueSheets","proto","attach_1","init","documentLocation","Component","defineElement","tag","elements","render","extractClass","omi","unbind","version","module","exports"],"mappings":"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","file":"omi.min.js","sourcesContent":["/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * This shim allows elements written in, or compiled to, ES5 to work on native\n * implementations of Custom Elements v1. It sets new.target to the value of\n * this.constructor so that the native HTMLElement constructor can access the\n * current under-construction element's definition.\n */\n;(function() {\n  if (\n    // No Reflect, no classes, no need for shim because native custom elements\n    // require ES2015 classes or Reflect.\n    window.Reflect === undefined ||\n    window.customElements === undefined ||\n    // The webcomponentsjs custom elements polyfill doesn't require\n    // ES2015-compatible construction (`super()` or `Reflect.construct`).\n    window.customElements.hasOwnProperty('polyfillWrapFlushCallback')\n  ) {\n    return\n  }\n  const BuiltInHTMLElement = HTMLElement\n  window.HTMLElement = function HTMLElement() {\n    return Reflect.construct(BuiltInHTMLElement, [], this.constructor)\n  }\n  HTMLElement.prototype = BuiltInHTMLElement.prototype\n  HTMLElement.prototype.constructor = HTMLElement\n  Object.setPrototypeOf(HTMLElement, BuiltInHTMLElement)\n})()\n\nexport function cssToDom(css) {\n  const node = document.createElement('style')\n  node.textContent = css\n  return node\n}\n\nexport function camelCase(str) {\n  return str.replace(/-(\\w)/g, ($, $1) => {\n    return $1.toUpperCase()\n  })\n}\n\nexport function Fragment(props) {\n  return props.children\n}\n\nexport function extend(obj, props) {\n  for (let i in props) obj[i] = props[i]\n  return obj\n}\n\n/** Invoke or update a ref, depending on whether it is a function or object ref.\n *  @param {object|function} [ref=null]\n *  @param {any} [value]\n */\nexport function applyRef(ref, value) {\n  if (ref != null) {\n    if (typeof ref == 'function') ref(value)\n    else ref.current = value\n  }\n}\n\n/**\n * Call a function asynchronously, as soon as possible. Makes\n * use of HTML Promise to schedule the callback if available,\n * otherwise falling back to `setTimeout` (mainly for IE<11).\n * @type {(callback: function) => void}\n */\nexport const defer =\n  typeof Promise == 'function'\n    ? Promise.resolve().then.bind(Promise.resolve())\n    : setTimeout\n\nexport function isArray(obj) {\n  return Object.prototype.toString.call(obj) === '[object Array]'\n}\n\nexport function pathToArr(path) {\n  if (typeof path !== 'string' || !path) return []\n  // return path.split(/\\.|\\[|\\]/).filter(name => !!name)\n  return path\n    .replace(/]/g, '')\n    .replace(/\\[/g, '.')\n    .split('.')\n}\n\nconst hyphenateRE = /\\B([A-Z])/g\nexport function hyphenate(str) {\n  return str.replace(hyphenateRE, '-$1').toLowerCase()\n}\n\nexport function getValByPath(path, current) {\n  const arr = pathToArr(path)\n  arr.forEach(prop => {\n    current = current[prop]\n  })\n  return current\n}\n\nexport function removeItem(item, arr) {\n  if (!arr) return\n  for (let i = 0, len = arr.length; i < len; i++) {\n    if (arr[i] === item) {\n      arr.splice(i, 1)\n      break\n    }\n  }\n}\n","import options from './options'\nimport { Fragment } from './util'\n\nconst stack = []\n\nexport function h(nodeName, attributes) {\n  let children = [],\n    lastSimple,\n    child,\n    simple,\n    i\n  for (i = arguments.length; i-- > 2; ) {\n    stack.push(arguments[i])\n  }\n  if (attributes && attributes.children != null) {\n    if (!stack.length) stack.push(attributes.children)\n    delete attributes.children\n  }\n  while (stack.length) {\n    if ((child = stack.pop()) && child.pop !== undefined) {\n      for (i = child.length; i--; ) stack.push(child[i])\n    } else {\n      if (typeof child === 'boolean') child = null\n\n      if ((simple = typeof nodeName !== 'function')) {\n        if (child == null) child = ''\n        else if (typeof child === 'number') child = String(child)\n        else if (typeof child !== 'string') simple = false\n      }\n\n      if (simple && lastSimple) {\n        children[children.length - 1] += child\n      } else if (children.length === 0) {\n        children = [child]\n      } else {\n        children.push(child)\n      }\n\n      lastSimple = simple\n    }\n  }\n\n  if (nodeName === Fragment) {\n    return children\n  }\n\n  const p = {\n    nodeName,\n    children,\n    attributes: attributes == null ? undefined : attributes,\n    key: attributes == null ? undefined : attributes.key\n  }\n\n  // if a \"vnode hook\" is defined, pass every created VNode to it\n  if (options.vnode !== undefined) options.vnode(p)\n\n  return p\n}\n","import { extend } from '../util'\nimport options from '../options'\n/**\n * Check if two nodes are equivalent.\n *\n * @param {Node} node      DOM Node to compare\n * @param {VNode} vnode      Virtual DOM node to compare\n * @param {boolean} [hydrating=false]  If true, ignores component constructors when comparing.\n * @private\n */\nexport function isSameNodeType(node, vnode, hydrating) {\n  if (typeof vnode === 'string' || typeof vnode === 'number') {\n    return node.splitText !== undefined\n  }\n  if (typeof vnode.nodeName === 'string') {\n    return !node._componentConstructor && isNamedNode(node, vnode.nodeName)\n  } else if (typeof vnode.nodeName === 'function') {\n    return options.mapping[node.nodeName.toLowerCase()] === vnode.nodeName\n  }\n  return hydrating || node._componentConstructor === vnode.nodeName\n}\n\n/**\n * Check if an Element has a given nodeName, case-insensitively.\n *\n * @param {Element} node  A DOM Element to inspect the name of.\n * @param {String} nodeName  Unnormalized name to compare against.\n */\nexport function isNamedNode(node, nodeName) {\n  return (\n    node.normalizedNodeName === nodeName ||\n    node.nodeName.toLowerCase() === nodeName.toLowerCase()\n  )\n}\n\n/**\n * Reconstruct Component-style `props` from a VNode.\n * Ensures default/fallback values from `defaultProps`:\n * Own-properties of `defaultProps` not present in `vnode.attributes` are added.\n *\n * @param {VNode} vnode\n * @returns {Object} props\n */\nexport function getNodeProps(vnode) {\n  let props = extend({}, vnode.attributes)\n  props.children = vnode.children\n\n  let defaultProps = vnode.nodeName.defaultProps\n  if (defaultProps !== undefined) {\n    for (let i in defaultProps) {\n      if (props[i] === undefined) {\n        props[i] = defaultProps[i]\n      }\n    }\n  }\n\n  return props\n}\n","import { pathToArr } from './util'\n\nexport const extension = {}\n\nexport function extend(name, handler) {\n  extension['o-' + name] = handler\n}\n\nexport function set(origin, path, value) {\n  const arr = pathToArr(path)\n  let current = origin\n  for (let i = 0, len = arr.length; i < len; i++) {\n    if (i === len - 1) {\n      current[arr[i]] = value\n    } else {\n      current = current[arr[i]]\n    }\n  }\n}\n\nexport function get(origin, path) {\n  const arr = pathToArr(path)\n  let current = origin\n  for (let i = 0, len = arr.length; i < len; i++) {\n    current = current[arr[i]]\n  }\n\n  return current\n}\n\nfunction eventProxy(e) {\n  return this._listeners[e.type](e)\n}\n\nexport function bind(el, type, handler) {\n  el._listeners = el._listeners || {}\n  el._listeners[type] = handler\n  el.addEventListener(type, eventProxy)\n}\n\nexport function unbind(el, type) {\n  el.removeEventListener(type, eventProxy)\n}\n","import { IS_NON_DIMENSIONAL } from '../constants'\nimport { applyRef } from '../util'\nimport options from '../options'\nimport { extension } from '../extend'\n\n/**\n * Create an element with the given nodeName.\n * @param {string} nodeName The DOM node to create\n * @param {boolean} [isSvg=false] If `true`, creates an element within the SVG\n *  namespace.\n * @returns {Element} The created DOM node\n */\nexport function createNode(nodeName, isSvg) {\n  /** @type {Element} */\n  let node = isSvg\n    ? document.createElementNS('http://www.w3.org/2000/svg', nodeName)\n    : document.createElement(nodeName)\n  node.normalizedNodeName = nodeName\n  return node\n}\n\n/**\n * Remove a child node from its parent if attached.\n * @param {Node} node The node to remove\n */\nexport function removeNode(node) {\n  let parentNode = node.parentNode\n  if (parentNode) parentNode.removeChild(node)\n}\n\n/**\n * Set a named attribute on the given Node, with special behavior for some names\n * and event handlers. If `value` is `null`, the attribute/handler will be\n * removed.\n * @param {Element} node An element to mutate\n * @param {string} name The name/key to set, such as an event or attribute name\n * @param {*} old The last value that was set for this name/node pair\n * @param {*} value An attribute value, such as a function to be used as an\n *  event handler\n * @param {boolean} isSvg Are we currently diffing inside an svg?\n * @private\n */\nexport function setAccessor(node, name, old, value, isSvg, component) {\n  if (name === 'className') name = 'class'\n\n  if (name[0] == 'o' && name[1] == '-') {\n    if (extension[name]) {\n      extension[name](node, value, component)\n    }\n  } else if (name === 'key') {\n    // ignore\n  } else if (name === 'ref') {\n    applyRef(old, null)\n    applyRef(value, node)\n  } else if (name === 'class' && !isSvg) {\n    node.className = value || ''\n  } else if (name === 'style') {\n    if (!value || typeof value === 'string' || typeof old === 'string') {\n      node.style.cssText = value || ''\n    }\n    if (value && typeof value === 'object') {\n      if (typeof old !== 'string') {\n        for (let i in old) if (!(i in value)) node.style[i] = ''\n      }\n      for (let i in value) {\n        node.style[i] =\n          typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false\n            ? value[i] + 'px'\n            : value[i]\n      }\n    }\n  } else if (name === 'dangerouslySetInnerHTML') {\n    if (value) node.innerHTML = value.__html || ''\n  } else if (\n    name[0] == '_' &&\n    name[1] == 'o' &&\n    name[2] == 'n' &&\n    node.constructor.is === 'WeElement'\n  ) {\n    bindEvent(node, name.replace('_', ''), value, old)\n  } else if (name[0] == 'o' && name[1] == 'n') {\n    bindEvent(node, name, value, old)\n  } else if (node.nodeName === 'INPUT' && name === 'value') {\n    node[name] = value == null ? '' : value\n  } else if (\n    name !== 'list' &&\n    name !== 'type' &&\n    name !== 'css' &&\n    !isSvg &&\n    name in node &&\n    value !== ''\n  ) {\n    //value !== '' fix for selected, disabled, checked with pure element\n    // Attempt to set a DOM property to the given value.\n    // IE & FF throw for certain property-value combinations.\n    try {\n      node[name] = value == null ? '' : value\n    } catch (e) {}\n    if ((value == null || value === false) && name != 'spellcheck')\n      node.pureRemoveAttribute\n        ? node.pureRemoveAttribute(name)\n        : node.removeAttribute(name)\n  } else {\n    let ns = isSvg && name !== (name = name.replace(/^xlink:?/, ''))\n    // spellcheck is treated differently than all other boolean values and\n    // should not be removed when the value is `false`. See:\n    // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-spellcheck\n    if (value == null || value === false) {\n      if (ns)\n        node.removeAttributeNS(\n          'http://www.w3.org/1999/xlink',\n          name.toLowerCase()\n        )\n      else\n        node.pureRemoveAttribute\n          ? node.pureRemoveAttribute(name)\n          : node.removeAttribute(name)\n    } else if (typeof value !== 'function') {\n      if (ns) {\n        node.setAttributeNS(\n          'http://www.w3.org/1999/xlink',\n          name.toLowerCase(),\n          value\n        )\n      } else {\n        node.pureSetAttribute\n          ? node.pureSetAttribute(name, value)\n          : node.setAttribute(name, value)\n      }\n    }\n  }\n}\n\n/**\n * Proxy an event to hooked event handlers\n * @param {Event} e The event object from the browser\n * @private\n */\nfunction eventProxy(e) {\n  return this._listeners[e.type]((options.event && options.event(e)) || e)\n}\n\nfunction bindEvent(node, name, value, old) {\n  let useCapture = name !== (name = name.replace(/Capture$/, ''))\n  let nameLower = name.toLowerCase()\n  name = (nameLower in node ? nameLower : name).slice(2)\n  if (value) {\n    if (!old) {\n      node.addEventListener(name, eventProxy, useCapture)\n    }\n  } else {\n    node.removeEventListener(name, eventProxy, useCapture)\n  }\n  ;(node._listeners || (node._listeners = {}))[name] = value\n}\n","import { ATTR_KEY } from '../constants'\nimport { isSameNodeType, isNamedNode } from './index'\nimport { createNode, setAccessor } from '../dom/index'\nimport { camelCase, isArray, Fragment } from '../util'\nimport { removeNode } from '../dom/index'\nimport options from '../options'\n\n/** Queue of components that have been mounted and are awaiting componentDidMount */\nexport const mounts = []\n\n/** Diff recursion count, used to track the end of the diff cycle. */\nexport let diffLevel = 0\n\n/** Global flag indicating if the diff is currently within an SVG */\nlet isSvgMode = false\n\n/** Global flag indicating if the diff is performing hydration */\nlet hydrating = false\n\n/** Apply differences in a given vnode (and it's deep children) to a real DOM Node.\n *  @param {Element} [dom=null]    A DOM node to mutate into the shape of the `vnode`\n *  @param {VNode} vnode      A VNode (with descendants forming a tree) representing the desired DOM structure\n *  @returns {Element} dom      The created/mutated element\n *  @private\n */\nexport function diff(dom, vnode, parent, component, updateSelf) {\n  //first render return undefined\n  if (!dom && !vnode) return\n  // diffLevel having been 0 here indicates initial entry into the diff (not a subdiff)\n  let ret\n  if (!diffLevel++) {\n    // when first starting the diff, check if we're diffing an SVG or within an SVG\n    isSvgMode = parent != null && parent.ownerSVGElement !== undefined\n\n    // hydration is indicated by the existing element to be diffed not having a prop cache\n    hydrating = dom != null && !(ATTR_KEY in dom)\n  }\n  if (vnode && vnode.nodeName === Fragment) {\n    vnode = vnode.children\n  }\n  if (isArray(vnode)) {\n    if (parent) {\n      //don't use css and props.css when using h.f\n      innerDiffNode(parent, vnode, hydrating, component, updateSelf)\n    } else {\n      ret = []\n      vnode.forEach((item, index) => {\n        let ele = idiff(index === 0 ? dom : null, item, component, updateSelf)\n        ret.push(ele)\n      })\n    }\n  } else {\n    if (isArray(dom)) {\n      dom.forEach((one, index) => {\n        if (index === 0) {\n          ret = idiff(one, vnode, component, updateSelf)\n        } else {\n          recollectNodeTree(one, false)\n        }\n      })\n    } else {\n      ret = idiff(dom, vnode, component, updateSelf)\n    }\n    // append the element if its a new parent\n    if (parent && ret.parentNode !== parent) parent.appendChild(ret)\n  }\n\n  // diffLevel being reduced to 0 means we're exiting the diff\n  if (!--diffLevel) {\n    hydrating = false\n    // invoke queued componentDidMount lifecycle methods\n  }\n\n  return ret\n}\n\n/** Internals of `diff()`, separated to allow bypassing diffLevel / mount flushing. */\nfunction idiff(dom, vnode, component, updateSelf) {\n  if (dom && vnode && dom.props) {\n    dom.props.children = vnode.children\n  }\n  let out = dom,\n    prevSvgMode = isSvgMode\n\n  // empty values (null, undefined, booleans) render as empty Text nodes\n  if (vnode == null || typeof vnode === 'boolean') vnode = ''\n\n  // Fast case: Strings & Numbers create/update Text nodes.\n  if (typeof vnode === 'string' || typeof vnode === 'number') {\n    // update if it's already a Text node:\n    if (\n      dom &&\n      dom.splitText !== undefined &&\n      dom.parentNode &&\n      (!dom._component || component)\n    ) {\n      /* istanbul ignore if */ /* Browser quirk that can't be covered: https://github.com/developit/preact/commit/fd4f21f5c45dfd75151bd27b4c217d8003aa5eb9 */\n      if (dom.nodeValue != vnode) {\n        dom.nodeValue = vnode\n      }\n    } else {\n      // it wasn't a Text node: replace it with one and recycle the old Element\n      out = document.createTextNode(vnode)\n      if (dom) {\n        if (dom.parentNode) dom.parentNode.replaceChild(out, dom)\n        recollectNodeTree(dom, true)\n      }\n    }\n\n    out[ATTR_KEY] = true\n\n    return out\n  }\n\n  // If the VNode represents a Component, perform a component diff:\n  let vnodeName = vnode.nodeName\n  if (typeof vnodeName === 'function') {\n    for (let key in options.mapping) {\n      if (options.mapping[key] === vnodeName) {\n        vnodeName = key\n        vnode.nodeName = key\n        break\n      }\n    }\n  }\n  // Tracks entering and exiting SVG namespace when descending through the tree.\n  isSvgMode =\n    vnodeName === 'svg'\n      ? true\n      : vnodeName === 'foreignObject'\n      ? false\n      : isSvgMode\n\n  // If there's no existing element or it's the wrong type, create a new one:\n  vnodeName = String(vnodeName)\n  if (!dom || !isNamedNode(dom, vnodeName)) {\n    out = createNode(vnodeName, isSvgMode)\n\n    if (dom) {\n      // move children into the replacement node\n      while (dom.firstChild) out.appendChild(dom.firstChild)\n\n      // if the previous Element was mounted into the DOM, replace it inline\n      if (dom.parentNode) dom.parentNode.replaceChild(out, dom)\n\n      // recycle the old element (skips non-Element node types)\n      recollectNodeTree(dom, true)\n    }\n  }\n\n  let fc = out.firstChild,\n    props = out[ATTR_KEY],\n    vchildren = vnode.children\n\n  if (props == null) {\n    props = out[ATTR_KEY] = {}\n    for (let a = out.attributes, i = a.length; i--; )\n      props[a[i].name] = a[i].value\n  }\n\n  // Optimization: fast-path for elements containing a single TextNode:\n  if (\n    !hydrating &&\n    vchildren &&\n    vchildren.length === 1 &&\n    typeof vchildren[0] === 'string' &&\n    fc != null &&\n    fc.splitText !== undefined &&\n    fc.nextSibling == null\n  ) {\n    if (fc.nodeValue != vchildren[0]) {\n      fc.nodeValue = vchildren[0]\n    }\n  }\n  // otherwise, if there are existing or new children, diff them:\n  else if ((vchildren && vchildren.length) || fc != null) {\n    if (!(out.constructor.is == 'WeElement' && out.constructor.noSlot)) {\n      innerDiffNode(\n        out,\n        vchildren,\n        hydrating || props.dangerouslySetInnerHTML != null,\n        component,\n        updateSelf\n      )\n    }\n  }\n\n  // Apply attributes/props from VNode to the DOM Element:\n  diffAttributes(out, vnode.attributes, props, component, updateSelf)\n  if (out.props) {\n    out.props.children = vnode.children\n  }\n  // restore previous SVG mode: (in case we're exiting an SVG namespace)\n  isSvgMode = prevSvgMode\n\n  return out\n}\n\n/** Apply child and attribute changes between a VNode and a DOM Node to the DOM.\n *  @param {Element} dom      Element whose children should be compared & mutated\n *  @param {Array} vchildren    Array of VNodes to compare to `dom.childNodes`\n *  @param {Boolean} isHydrating  If `true`, consumes externally created elements similar to hydration\n */\nfunction innerDiffNode(dom, vchildren, isHydrating, component, updateSelf) {\n  let originalChildren = dom.childNodes,\n    children = [],\n    keyed = {},\n    keyedLen = 0,\n    min = 0,\n    len = originalChildren.length,\n    childrenLen = 0,\n    vlen = vchildren ? vchildren.length : 0,\n    j,\n    c,\n    f,\n    vchild,\n    child\n\n  // Build up a map of keyed children and an Array of unkeyed children:\n  if (len !== 0) {\n    for (let i = 0; i < len; i++) {\n      let child = originalChildren[i],\n        props = child[ATTR_KEY],\n        key =\n          vlen && props\n            ? child._component\n              ? child._component.__key\n              : props.key\n            : null\n      if (key != null) {\n        keyedLen++\n        keyed[key] = child\n      } else if (\n        props ||\n        (child.splitText !== undefined\n          ? isHydrating\n            ? child.nodeValue.trim()\n            : true\n          : isHydrating)\n      ) {\n        children[childrenLen++] = child\n      }\n    }\n  }\n\n  if (vlen !== 0) {\n    for (let i = 0; i < vlen; i++) {\n      vchild = vchildren[i]\n      child = null\n\n      if (vchild) {\n        // attempt to find a node based on key matching\n        let key = vchild.key\n        if (key != null) {\n          if (keyedLen && keyed[key] !== undefined) {\n            child = keyed[key]\n            keyed[key] = undefined\n            keyedLen--\n          }\n        }\n        // attempt to pluck a node of the same type from the existing children\n        else if (!child && min < childrenLen) {\n          for (j = min; j < childrenLen; j++) {\n            if (\n              children[j] !== undefined &&\n              isSameNodeType((c = children[j]), vchild, isHydrating)\n            ) {\n              child = c\n              children[j] = undefined\n              if (j === childrenLen - 1) childrenLen--\n              if (j === min) min++\n              break\n            }\n          }\n        }\n      }\n\n      // morph the matched/found/created DOM child to match vchild (deep)\n      child = idiff(child, vchild, component, updateSelf)\n\n      f = originalChildren[i]\n      if (child && child !== dom && child !== f) {\n        if (f == null) {\n          dom.appendChild(child)\n        } else if (child === f.nextSibling) {\n          removeNode(f)\n        } else {\n          dom.insertBefore(child, f)\n        }\n      }\n    }\n  }\n\n  // remove unused keyed children:\n  if (keyedLen) {\n    for (let i in keyed)\n      if (keyed[i] !== undefined) recollectNodeTree(keyed[i], false)\n  }\n\n  // remove orphaned unkeyed children:\n  while (min <= childrenLen) {\n    if ((child = children[childrenLen--]) !== undefined)\n      recollectNodeTree(child, false)\n  }\n}\n\n/** Recursively recycle (or just unmount) a node and its descendants.\n *  @param {Node} node            DOM node to start unmount/removal from\n *  @param {Boolean} [unmountOnly=false]  If `true`, only triggers unmount lifecycle, skips removal\n */\nexport function recollectNodeTree(node, unmountOnly) {\n  // If the node's VNode had a ref function, invoke it with null here.\n  // (this is part of the React spec, and smart for unsetting references)\n  if (node[ATTR_KEY] != null && node[ATTR_KEY].ref) {\n    if (typeof node[ATTR_KEY].ref === 'function') {\n      node[ATTR_KEY].ref(null)\n    } else if (node[ATTR_KEY].ref.current) {\n      node[ATTR_KEY].ref.current = null\n    }\n  }\n\n  if (unmountOnly === false || node[ATTR_KEY] == null) {\n    removeNode(node)\n  }\n\n  removeChildren(node)\n}\n\n/** Recollect/unmount all children.\n *  - we use .lastChild here because it causes less reflow than .firstChild\n *  - it's also cheaper than accessing the .childNodes Live NodeList\n */\nexport function removeChildren(node) {\n  node = node.lastChild\n  while (node) {\n    let next = node.previousSibling\n    recollectNodeTree(node, true)\n    node = next\n  }\n}\n\n/** Apply differences in attributes from a VNode to the given DOM Element.\n *  @param {Element} dom    Element with attributes to diff `attrs` against\n *  @param {Object} attrs    The desired end-state key-value attribute pairs\n *  @param {Object} old      Current/previous attributes (from previous VNode or element's prop cache)\n */\nfunction diffAttributes(dom, attrs, old, component, updateSelf) {\n  let name\n  //let update = false\n  let isWeElement = dom.update\n  let oldClone\n  if (dom.receiveProps) {\n    oldClone = Object.assign({}, old)\n  }\n  // remove attributes no longer present on the vnode by setting them to undefined\n  for (name in old) {\n    if (!(attrs && attrs[name] != null) && old[name] != null) {\n      setAccessor(\n        dom,\n        name,\n        old[name],\n        (old[name] = undefined),\n        isSvgMode,\n        component\n      )\n      if (isWeElement) {\n        delete dom.props[name]\n        //update = true\n      }\n    }\n  }\n\n  // add new & update changed attributes\n  for (name in attrs) {\n    if (isWeElement && typeof attrs[name] === 'object' && name !== 'ref') {\n      if (name === 'style') {\n        setAccessor(\n          dom,\n          name,\n          old[name],\n          (old[name] = attrs[name]),\n          isSvgMode,\n          component\n        )\n      }\n      let ccName = camelCase(name)\n      dom.props[ccName] = old[ccName] = attrs[name]\n      //update = true\n    } else if (\n      name !== 'children' &&\n      (!(name in old) ||\n        attrs[name] !==\n          (name === 'value' || name === 'checked' ? dom[name] : old[name]))\n    ) {\n      setAccessor(dom, name, old[name], attrs[name], isSvgMode, component)\n      //fix lazy load props missing\n      if (dom.nodeName.indexOf('-') !== -1) {\n        dom.props = dom.props || {}\n        let ccName = camelCase(name)\n        dom.props[ccName] = old[ccName] = attrs[name]\n        //update = true\n      } else {\n        old[name] = attrs[name]\n      }\n    }\n  }\n\n  if (isWeElement && !updateSelf && dom.parentNode) {\n    //__hasChildren is not accuracy when it was empty at first, so add dom.children.length > 0 condition\n    //if (update || dom.__hasChildren || dom.children.length > 0 || (dom.store && !dom.store.data)) {\n    if (dom.receiveProps(dom.props, oldClone) !== false) {\n      dom.update()\n    }\n    //}\n  }\n}\n","import { cssToDom, isArray, hyphenate, getValByPath, removeItem } from './util'\nimport { diff } from './vdom/diff'\nimport options from './options'\n\nlet id = 0\n\nexport default class WeElement extends HTMLElement {\n  static is = 'WeElement'\n\n  constructor() {\n    super()\n    // fix lazy load props missing\n    this.props = Object.assign({}, this.constructor.defaultProps, this.props)\n    this.elementId = id++\n    this.computed = {}\n    this.isInstalled = false\n  }\n\n  connectedCallback() {\n    let p = this.parentNode\n    while (p && !this.store) {\n      this.store = p.store\n      p = p.parentNode || p.host\n    }\n\n    this.attrsToProps()\n\n    this.beforeInstall()\n    this.install()\n    this.afterInstall()\n\n    let shadowRoot\n    if (this.constructor.isLightDom) {\n      shadowRoot = this\n    } else {\n      if (!this.shadowRoot) {\n        shadowRoot = this.attachShadow({\n          mode: 'open'\n        })\n      } else {\n        shadowRoot = this.shadowRoot\n        let fc\n        while ((fc = shadowRoot.firstChild)) {\n          shadowRoot.removeChild(fc)\n        }\n      }\n    }\n\n    const css = this.constructor.css\n    if (css) {\n      if (typeof css === 'string') {\n        const styleSheet = new CSSStyleSheet()\n        styleSheet.replaceSync(css)\n        shadowRoot.adoptedStyleSheets = [styleSheet]\n      } else if (Object.prototype.toString.call(css) === '[object Array]') {\n        const styleSheets = []\n        css.forEach(styleSheet => {\n          if (typeof styleSheet === 'string') {\n            const adoptedStyleSheet = new CSSStyleSheet()\n            adoptedStyleSheet.replaceSync(styleSheet)\n            styleSheets.push(adoptedStyleSheet)\n          } else {\n            styleSheets.push(styleSheet)\n          }\n          shadowRoot.adoptedStyleSheets = styleSheets\n        })\n      } else {\n        shadowRoot.adoptedStyleSheets = [css]\n      }\n    }\n\n    this.beforeRender()\n    options.afterInstall && options.afterInstall(this)\n\n    const rendered = this.render(this.props, this.store)\n\n    this.rootNode = diff(null, rendered, null, this)\n    this.rendered()\n\n    if (this.css) {\n      shadowRoot.appendChild(\n        cssToDom(typeof this.css === 'function' ? this.css() : this.css)\n      )\n    }\n\n    if (this.props.css) {\n      this._customStyleElement = cssToDom(this.props.css)\n      this._customStyleContent = this.props.css\n      shadowRoot.appendChild(this._customStyleElement)\n    }\n\n    if (isArray(this.rootNode)) {\n      this.rootNode.forEach(function(item) {\n        shadowRoot.appendChild(item)\n      })\n    } else {\n      this.rootNode && shadowRoot.appendChild(this.rootNode)\n    }\n    this.installed()\n    this.isInstalled = true\n  }\n\n  disconnectedCallback() {\n    this.uninstall()\n    this.isInstalled = false\n  }\n\n  update(ignoreAttrs, updateSelf) {\n    this._willUpdate = true\n    this.beforeUpdate()\n    this.beforeRender()\n    //fix null !== undefined\n    if (this._customStyleContent != this.props.css) {\n      this._customStyleContent = this.props.css\n      this._customStyleElement.textContent = this._customStyleContent\n    }\n    this.attrsToProps(ignoreAttrs)\n\n    const rendered = this.render(this.props, this.store)\n    this.rendered()\n\n    this.rootNode = diff(\n      this.rootNode,\n      rendered,\n      this.constructor.isLightDom ? this : this.shadowRoot,\n      this,\n      updateSelf\n    )\n    this._willUpdate = false\n    this.updated()\n  }\n\n  forceUpdate() {\n    this.update(true)\n  }\n\n  updateProps(obj) {\n    Object.keys(obj).forEach(key => {\n      this.props[key] = obj[key]\n      if (this.prevProps) {\n        this.prevProps[key] = obj[key]\n      }\n    })\n    this.forceUpdate()\n  }\n\n  updateSelf(ignoreAttrs) {\n    this.update(ignoreAttrs, true)\n  }\n\n  removeAttribute(key) {\n    super.removeAttribute(key)\n    //Avoid executing removeAttribute methods before connectedCallback\n    this.isInstalled && this.update()\n  }\n\n  setAttribute(key, val) {\n    if (val && typeof val === 'object') {\n      super.setAttribute(key, JSON.stringify(val))\n    } else {\n      super.setAttribute(key, val)\n    }\n    //Avoid executing setAttribute methods before connectedCallback\n    this.isInstalled && this.update()\n  }\n\n  pureRemoveAttribute(key) {\n    super.removeAttribute(key)\n  }\n\n  pureSetAttribute(key, val) {\n    super.setAttribute(key, val)\n  }\n\n  attrsToProps(ignoreAttrs) {\n    if (\n      ignoreAttrs ||\n      (this.store && this.store.ignoreAttrs) ||\n      this.props.ignoreAttrs\n    )\n      return\n    const ele = this\n    ele.props['css'] = ele.getAttribute('css')\n    const attrs = this.constructor.propTypes\n    if (!attrs) return\n    Object.keys(attrs).forEach(key => {\n      const type = attrs[key]\n      const val = ele.getAttribute(hyphenate(key))\n      if (val !== null) {\n        switch (type) {\n          case String:\n            ele.props[key] = val\n            break\n          case Number:\n            ele.props[key] = Number(val)\n            break\n          case Boolean:\n            if (val === 'false' || val === '0') {\n              ele.props[key] = false\n            } else {\n              ele.props[key] = true\n            }\n            break\n          case Array:\n          case Object:\n            if (val[0] === ':') {\n              ele.props[key] = getValByPath(val.substr(1), Omi.$)\n            } else {\n              ele.props[key] = JSON.parse(\n                val\n                  .replace(/(['\"])?([a-zA-Z0-9_-]+)(['\"])?:([^\\/])/g, '\"$2\":$4')\n                  .replace(/'([\\s\\S]*?)'/g, '\"$1\"')\n                  .replace(/,(\\s*})/g, '$1')\n              )\n            }\n            break\n        }\n      } else {\n        if (\n          ele.constructor.defaultProps &&\n          ele.constructor.defaultProps.hasOwnProperty(key)\n        ) {\n          ele.props[key] = ele.constructor.defaultProps[key]\n        } else {\n          ele.props[key] = null\n        }\n      }\n    })\n  }\n\n  fire(name, data) {\n    this.dispatchEvent(\n      new CustomEvent(name, {\n        detail: data\n      })\n    )\n  }\n\n  beforeInstall() {}\n\n  install() {}\n\n  afterInstall() {}\n\n  installed() {}\n\n  uninstall() {}\n\n  beforeUpdate() {}\n\n  updated() {}\n\n  beforeRender() {}\n\n  rendered() {}\n\n  receiveProps() {}\n}\n","import { diff } from './vdom/diff'\n\nexport function render(vnode, parent, store) {\n  parent = typeof parent === 'string' ? document.querySelector(parent) : parent\n  if (store) {\n    parent.store = store\n  }\n  return diff(null, vnode, parent, false)\n}\n","import WeElement from './we-element'\nimport options from './options'\n\nconst storeHelpers = ['use', 'useSelf']\n\nexport function define(name, ctor, config) {\n  if (customElements.get(name)) {\n    return\n  }\n  if (options.mapping[name]) {\n    return\n  }\n  if (ctor.is === 'WeElement') {\n    customElements.define(name, ctor)\n    options.mapping[name] = ctor\n  } else {\n    if (typeof config === 'string') {\n      config = { css: config }\n    } else {\n      config = config || {}\n    }\n\n    class Ele extends WeElement {\n      static css = config.css\n\n      static propTypes = config.propTypes\n\n      static defaultProps = config.defaultProps\n\n      static isLightDom = config.isLightDom\n\n      compute = config.compute\n\n      render() {\n        return ctor.call(this, this)\n      }\n    }\n\n    for (let key in config) {\n      if (typeof config[key] === 'function') {\n        Ele.prototype[key] = function() {\n          return config[key].apply(this, arguments)\n        }\n      }\n    }\n\n    storeHelpers.forEach(func => {\n      if (config[func] && config[func] !== 'function') {\n        Ele.prototype[func] = function() {\n          return config[func]\n        }\n      }\n    })\n\n    customElements.define(name, Ele)\n    options.mapping[name] = Ele\n  }\n}\n","import { extend } from './util'\nimport { h } from './h'\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {VNode} vnode    The virtual DOM element to clone\n * @param {Object} props  Attributes/props to add when cloning\n * @param {VNode} rest    Any additional arguments will be used as replacement children.\n */\nexport function cloneElement(vnode, props) {\n  return h(\n    vnode.nodeName,\n    extend(extend({}, vnode.attributes), props),\n    arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children\n  )\n}\n","export function getHost(ele) {\n  let p = ele.parentNode\n  while (p) {\n    if (p.host) {\n      return p.host\n    } else if (p.shadowRoot && p.shadowRoot.host) {\n      return p.shadowRoot.host\n    } else {\n      p = p.parentNode\n    }\n  }\n}\n","/**\n * classNames based on https://github.com/JedWatson/classnames\n * by Jed Watson\n * Licensed under the MIT License\n * https://github.com/JedWatson/classnames/blob/master/LICENSE\n * modified by dntzhang\n */\n\nvar hasOwn = {}.hasOwnProperty\n\nexport function classNames() {\n  var classes = []\n\n  for (var i = 0; i < arguments.length; i++) {\n    var arg = arguments[i]\n    if (!arg) continue\n\n    var argType = typeof arg\n\n    if (argType === 'string' || argType === 'number') {\n      classes.push(arg)\n    } else if (Array.isArray(arg) && arg.length) {\n      var inner = classNames.apply(null, arg)\n      if (inner) {\n        classes.push(inner)\n      }\n    } else if (argType === 'object') {\n      for (var key in arg) {\n        if (hasOwn.call(arg, key) && arg[key]) {\n          classes.push(key)\n        }\n      }\n    }\n  }\n\n  return classes.join(' ')\n}\n\nexport function extractClass() {\n  const [props, ...args] = Array.prototype.slice.call(arguments, 0)\n  if (props.class) {\n    args.unshift(props.class)\n    delete props.class\n  } else if (props.className) {\n    args.unshift(props.className)\n    delete props.className\n  }\n  if (args.length > 0) {\n    return { class: classNames.apply(null, args) }\n  }\n}\n","(function () {\n    'use strict';\n\n    if ('adoptedStyleSheets' in document) { return; }\n\n    var hasShadyCss = 'ShadyCSS' in window && !ShadyCSS.nativeShadow;\n    var bootstrapper = document.implementation.createHTMLDocument('boot');\n    var closedShadowRootRegistry = new WeakMap();\n    var _DOMException = typeof DOMException === 'object' ? Error : DOMException;\n\n    var defineProperty = Object.defineProperty;\n    var forEach = Array.prototype.forEach;\n    var importPattern = /@import.+?;?$/gm;\n    function rejectImports(contents) {\n        var _contents = contents.replace(importPattern, '');\n        if (_contents !== contents) {\n            console.warn('@import rules are not allowed here. See https://github.com/WICG/construct-stylesheets/issues/119#issuecomment-588352418');\n        }\n        return _contents.trim();\n    }\n    function clearRules(sheet) {\n        for (var i = 0; i < sheet.cssRules.length; i++) {\n            sheet.deleteRule(0);\n        }\n    }\n    function insertAllRules(from, to) {\n        forEach.call(from.cssRules, function (rule, i) {\n            to.insertRule(rule.cssText, i);\n        });\n    }\n    function isElementConnected(element) {\n        return 'isConnected' in element\n            ? element.isConnected\n            : document.contains(element);\n    }\n    function unique(arr) {\n        return arr.filter(function (value, index) { return arr.indexOf(value) === index; });\n    }\n    function diff(arr1, arr2) {\n        return arr1.filter(function (value) { return arr2.indexOf(value) === -1; });\n    }\n    function removeNode(node) {\n        node.parentNode.removeChild(node);\n    }\n    function getShadowRoot(element) {\n        return element.shadowRoot || closedShadowRootRegistry.get(element);\n    }\n\n    var cssStyleSheetMethods = [\n        'addImport',\n        'addPageRule',\n        'addRule',\n        'deleteRule',\n        'insertRule',\n        'removeImport',\n        'removeRule',\n    ];\n    var NonConstructedStyleSheet = CSSStyleSheet;\n    var nonConstructedProto = NonConstructedStyleSheet.prototype;\n    nonConstructedProto.replace = function () {\n        return Promise.reject(new _DOMException(\"Can't call replace on non-constructed CSSStyleSheets.\"));\n    };\n    nonConstructedProto.replaceSync = function () {\n        throw new _DOMException(\"Failed to execute 'replaceSync' on 'CSSStyleSheet': Can't call replaceSync on non-constructed CSSStyleSheets.\");\n    };\n    function isCSSStyleSheetInstance(instance) {\n        return typeof instance === 'object'\n            ? proto$2.isPrototypeOf(instance) ||\n                nonConstructedProto.isPrototypeOf(instance)\n            : false;\n    }\n    function isNonConstructedStyleSheetInstance(instance) {\n        return typeof instance === 'object'\n            ? nonConstructedProto.isPrototypeOf(instance)\n            : false;\n    }\n    var $basicStyleSheet = new WeakMap();\n    var $locations = new WeakMap();\n    var $adoptersByLocation = new WeakMap();\n    function addAdopterLocation(sheet, location) {\n        var adopter = document.createElement('style');\n        $adoptersByLocation.get(sheet).set(location, adopter);\n        $locations.get(sheet).push(location);\n        return adopter;\n    }\n    function getAdopterByLocation(sheet, location) {\n        return $adoptersByLocation.get(sheet).get(location);\n    }\n    function removeAdopterLocation(sheet, location) {\n        $adoptersByLocation.get(sheet).delete(location);\n        $locations.set(sheet, $locations.get(sheet).filter(function (_location) { return _location !== location; }));\n    }\n    function restyleAdopter(sheet, adopter) {\n        requestAnimationFrame(function () {\n            clearRules(adopter.sheet);\n            insertAllRules($basicStyleSheet.get(sheet), adopter.sheet);\n        });\n    }\n    function checkInvocationCorrectness(self) {\n        if (!$basicStyleSheet.has(self)) {\n            throw new TypeError('Illegal invocation');\n        }\n    }\n    function ConstructedStyleSheet() {\n        var self = this;\n        var style = document.createElement('style');\n        bootstrapper.body.appendChild(style);\n        $basicStyleSheet.set(self, style.sheet);\n        $locations.set(self, []);\n        $adoptersByLocation.set(self, new WeakMap());\n    }\n    var proto$2 = ConstructedStyleSheet.prototype;\n    proto$2.replace = function replace(contents) {\n        try {\n            this.replaceSync(contents);\n            return Promise.resolve(this);\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    };\n    proto$2.replaceSync = function replaceSync(contents) {\n        checkInvocationCorrectness(this);\n        if (typeof contents === 'string') {\n            var self_1 = this;\n            var style = $basicStyleSheet.get(self_1).ownerNode;\n            style.textContent = rejectImports(contents);\n            $basicStyleSheet.set(self_1, style.sheet);\n            $locations.get(self_1).forEach(function (location) {\n                if (location.isConnected()) {\n                    restyleAdopter(self_1, getAdopterByLocation(self_1, location));\n                }\n            });\n        }\n    };\n    defineProperty(proto$2, 'cssRules', {\n        configurable: true,\n        enumerable: true,\n        get: function cssRules() {\n            checkInvocationCorrectness(this);\n            return $basicStyleSheet.get(this).cssRules;\n        },\n    });\n    cssStyleSheetMethods.forEach(function (method) {\n        proto$2[method] = function () {\n            var self = this;\n            checkInvocationCorrectness(self);\n            var args = arguments;\n            var basic = $basicStyleSheet.get(self);\n            var locations = $locations.get(self);\n            var result = basic[method].apply(basic, args);\n            locations.forEach(function (location) {\n                if (location.isConnected()) {\n                    var sheet = getAdopterByLocation(self, location).sheet;\n                    sheet[method].apply(sheet, args);\n                }\n            });\n            return result;\n        };\n    });\n    defineProperty(ConstructedStyleSheet, Symbol.hasInstance, {\n        configurable: true,\n        value: isCSSStyleSheetInstance,\n    });\n\n    var defaultObserverOptions = {\n        childList: true,\n        subtree: true,\n    };\n    var locations = new WeakMap();\n    function getAssociatedLocation(element) {\n        var location = locations.get(element);\n        if (!location) {\n            location = new Location(element);\n            locations.set(element, location);\n        }\n        return location;\n    }\n    function attachAdoptedStyleSheetProperty(constructor) {\n        defineProperty(constructor.prototype, 'adoptedStyleSheets', {\n            configurable: true,\n            enumerable: true,\n            get: function () {\n                return getAssociatedLocation(this).sheets;\n            },\n            set: function (sheets) {\n                getAssociatedLocation(this).update(sheets);\n            },\n        });\n    }\n    function traverseWebComponents(node, callback) {\n        var iter = document.createNodeIterator(node, NodeFilter.SHOW_ELEMENT, function (foundNode) {\n            return getShadowRoot(foundNode)\n                ? NodeFilter.FILTER_ACCEPT\n                : NodeFilter.FILTER_REJECT;\n        },\n        null, false);\n        for (var next = void 0; (next = iter.nextNode());) {\n            callback(getShadowRoot(next));\n        }\n    }\n    var $element = new WeakMap();\n    var $uniqueSheets = new WeakMap();\n    var $observer = new WeakMap();\n    function isExistingAdopter(self, element) {\n        return (element instanceof HTMLStyleElement &&\n            $uniqueSheets.get(self).some(function (sheet) { return getAdopterByLocation(sheet, self); }));\n    }\n    function getAdopterContainer(self) {\n        var element = $element.get(self);\n        return element instanceof Document ? element.body : element;\n    }\n    function adopt(self) {\n        var styleList = document.createDocumentFragment();\n        var sheets = $uniqueSheets.get(self);\n        var observer = $observer.get(self);\n        var container = getAdopterContainer(self);\n        observer.disconnect();\n        sheets.forEach(function (sheet) {\n            styleList.appendChild(getAdopterByLocation(sheet, self) || addAdopterLocation(sheet, self));\n        });\n        container.insertBefore(styleList, null);\n        observer.observe(container, defaultObserverOptions);\n        sheets.forEach(function (sheet) {\n            restyleAdopter(sheet, getAdopterByLocation(sheet, self));\n        });\n    }\n    function Location(element) {\n        var self = this;\n        self.sheets = [];\n        $element.set(self, element);\n        $uniqueSheets.set(self, []);\n        $observer.set(self, new MutationObserver(function (mutations, observer) {\n            if (!document) {\n                observer.disconnect();\n                return;\n            }\n            mutations.forEach(function (mutation) {\n                if (!hasShadyCss) {\n                    forEach.call(mutation.addedNodes, function (node) {\n                        if (!(node instanceof Element)) {\n                            return;\n                        }\n                        traverseWebComponents(node, function (root) {\n                            getAssociatedLocation(root).connect();\n                        });\n                    });\n                }\n                forEach.call(mutation.removedNodes, function (node) {\n                    if (!(node instanceof Element)) {\n                        return;\n                    }\n                    if (isExistingAdopter(self, node)) {\n                        adopt(self);\n                    }\n                    if (!hasShadyCss) {\n                        traverseWebComponents(node, function (root) {\n                            getAssociatedLocation(root).disconnect();\n                        });\n                    }\n                });\n            });\n        }));\n    }\n    var proto$1 = Location.prototype;\n    proto$1.isConnected = function isConnected() {\n        var element = $element.get(this);\n        return element instanceof Document\n            ? element.readyState !== 'loading'\n            : isElementConnected(element.host);\n    };\n    proto$1.connect = function connect() {\n        var container = getAdopterContainer(this);\n        $observer.get(this).observe(container, defaultObserverOptions);\n        if ($uniqueSheets.get(this).length > 0) {\n            adopt(this);\n        }\n        traverseWebComponents(container, function (root) {\n            getAssociatedLocation(root).connect();\n        });\n    };\n    proto$1.disconnect = function disconnect() {\n        $observer.get(this).disconnect();\n    };\n    proto$1.update = function update(sheets) {\n        var self = this;\n        var locationType = $element.get(self) === document ? 'Document' : 'ShadowRoot';\n        if (!Array.isArray(sheets)) {\n            throw new TypeError(\"Failed to set the 'adoptedStyleSheets' property on \" + locationType + \": Iterator getter is not callable.\");\n        }\n        if (!sheets.every(isCSSStyleSheetInstance)) {\n            throw new TypeError(\"Failed to set the 'adoptedStyleSheets' property on \" + locationType + \": Failed to convert value to 'CSSStyleSheet'\");\n        }\n        if (sheets.some(isNonConstructedStyleSheetInstance)) {\n            throw new TypeError(\"Failed to set the 'adoptedStyleSheets' property on \" + locationType + \": Can't adopt non-constructed stylesheets\");\n        }\n        self.sheets = sheets;\n        var oldUniqueSheets = $uniqueSheets.get(self);\n        var uniqueSheets = unique(sheets);\n        var removedSheets = diff(oldUniqueSheets, uniqueSheets);\n        removedSheets.forEach(function (sheet) {\n            removeNode(getAdopterByLocation(sheet, self));\n            removeAdopterLocation(sheet, self);\n        });\n        $uniqueSheets.set(self, uniqueSheets);\n        if (self.isConnected() && uniqueSheets.length > 0) {\n            adopt(self);\n        }\n    };\n\n    window.CSSStyleSheet = ConstructedStyleSheet;\n    attachAdoptedStyleSheetProperty(Document);\n    if ('ShadowRoot' in window) {\n        attachAdoptedStyleSheetProperty(ShadowRoot);\n        var proto = Element.prototype;\n        var attach_1 = proto.attachShadow;\n        proto.attachShadow = function attachShadow(init) {\n            var root = attach_1.call(this, init);\n            if (init.mode === 'closed') {\n                closedShadowRootRegistry.set(this, root);\n            }\n            return root;\n        };\n    }\n    var documentLocation = getAssociatedLocation(document);\n    if (documentLocation.isConnected()) {\n        documentLocation.connect();\n    }\n    else {\n        document.addEventListener('DOMContentLoaded', documentLocation.connect.bind(documentLocation));\n    }\n\n}());\n","function getGlobal() {\n  if (\n    typeof global !== 'object' ||\n    !global ||\n    global.Math !== Math ||\n    global.Array !== Array\n  ) {\n    return (\n      self ||\n      window ||\n      global ||\n      (function() {\n        return this\n      })()\n    )\n  }\n  return global\n}\n\n/** Global options\n *  @public\n *  @namespace options {Object}\n */\nexport default {\n  store: null,\n  root: getGlobal(),\n  mapping: {}\n}\n","export function o(obj) {\n  return JSON.stringify(obj)\n}\n","import { h, h as createElement } from './h'\nimport options from './options'\nimport WeElement from './we-element'\nimport { render } from './render'\nimport { define } from './define'\nimport { tag } from './tag'\nimport { cloneElement } from './clone-element'\nimport { getHost } from './get-host'\nimport { rpx } from './rpx'\nimport { classNames, extractClass } from './class'\nimport { o } from './o'\nimport { extend, get, set, bind, unbind } from './extend'\nimport { Fragment } from './util'\nimport 'construct-style-sheets-polyfill'\n\nh.f = Fragment\n\nfunction createRef() {\n  return {}\n}\n\nconst $ = {}\nconst Component = WeElement\nconst defineElement = define\nconst elements = options.mapping\n\nconst omi = {\n  tag,\n  WeElement,\n  Component,\n  render,\n  h,\n  createElement,\n  options,\n  define,\n  cloneElement,\n  getHost,\n  rpx,\n  defineElement,\n  classNames,\n  extractClass,\n  createRef,\n  o,\n  elements,\n  $,\n  extend,\n  get,\n  set,\n  bind,\n  unbind\n}\n\noptions.root.Omi = omi\noptions.root.omi = omi\noptions.root.Omi.version = '6.20.1'\n\nexport default omi\n\nexport {\n  tag,\n  WeElement,\n  Component,\n  render,\n  h,\n  createElement,\n  options,\n  define,\n  cloneElement,\n  getHost,\n  rpx,\n  defineElement,\n  classNames,\n  extractClass,\n  createRef,\n  o,\n  elements,\n  $,\n  extend,\n  get,\n  set,\n  bind,\n  unbind\n}\n"]}