https://gruporp.es/themes/grupo-rp/assets/js/theme.js?tp=1

282	    var _e = undefined;
283
284	    try {
285	      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
286	        _arr.push(_s.value);
287
288	        if (i && _arr.length === i) break;
289	      }
290	    } catch (err) {
291	      _d = true;
292	      _e = err;
293	    } finally {
294	      try {
295	        if (!_n && _i["return"] != null) _i["return"]();
296	      } finally {
297	        if (_d) throw _e;
298	      }
299	    }
300
301	    return _arr;
302	  }
303
304	  function _nonIterableSpread() {
305	    throw new TypeError("Invalid attempt to spread non-iterable instance");
306	  }
307
308	  function _nonIterableRest() {
309	    throw new TypeError("Invalid attempt to destructure non-iterable instance");
310	  }
311
312	  var noop = function noop() {};
313
314	  var _WINDOW = {};
315	  var _DOCUMENT = {};
316	  var _MUTATION_OBSERVER = null;
317	  var _PERFORMANCE = {
318	    mark: noop,
319	    measure: noop
320	  };
321
322	  try {
323	    if (typeof window !== 'undefined') _WINDOW = window;
324	    if (typeof document !== 'undefined') _DOCUMENT = document;
325	    if (typeof MutationObserver !== 'undefined') _MUTATION_OBSERVER = MutationObserver;
326	    if (typeof performance !== 'undefined') _PERFORMANCE = performance;
327	  } catch (e) {}
328
329	  var _ref = _WINDOW.navigator || {},
330	      _ref$userAgent = _ref.userAgent,
331	      userAgent = _ref$userAgent === void 0 ? '' : _ref$userAgent;
332
333	  var WINDOW = _WINDOW;
334	  var DOCUMENT = _DOCUMENT;
335	  var MUTATION_OBSERVER = _MUTATION_OBSERVER;
336	  var PERFORMANCE = _PERFORMANCE;
337	  var IS_BROWSER = !!WINDOW.document;
338	  var IS_DOM = !!DOCUMENT.documentElement && !!DOCUMENT.head && typeof DOCUMENT.addEventListener === 'function' && typeof DOCUMENT.createElement === 'function';
339	  var IS_IE = ~userAgent.indexOf('MSIE') || ~userAgent.indexOf('Trident/');
340
341	  var NAMESPACE_IDENTIFIER = '___FONT_AWESOME___';
342	  var UNITS_IN_GRID = 16;
343	  var DEFAULT_FAMILY_PREFIX = 'fa';
344	  var DEFAULT_REPLACEMENT_CLASS = 'svg-inline--fa';
345	  var DATA_FA_I2SVG = 'data-fa-i2svg';
346	  var DATA_FA_PSEUDO_ELEMENT = 'data-fa-pseudo-element';
347	  var DATA_FA_PSEUDO_ELEMENT_PENDING = 'data-fa-pseudo-element-pending';
348	  var DATA_PREFIX = 'data-prefix';
349	  var DATA_ICON = 'data-icon';
350	  var HTML_CLASS_I2SVG_BASE_CLASS = 'fontawesome-i2svg';
351	  var TAGNAMES_TO_SKIP_FOR_PSEUDOELEMENTS = ['HTML', 'HEAD', 'STYLE', 'SCRIPT'];
352	  var PRODUCTION = function () {
353	    try {
354	      return process.env.NODE_ENV === 'production';
355	    } catch (e) {
356	      return false;
357	    }
358	  }();
359	  var PREFIX_TO_STYLE = {
360	    'fas': 'solid',
361	    'far': 'regular',
362	    'fal': 'light',
363	    'fab': 'brands',
364	    'fa': 'solid'
365	  };
366	  var STYLE_TO_PREFIX = {
367	    'solid': 'fas',
368	    'regular': 'far',
369	    'light': 'fal',
370	    'brands': 'fab'
371	  };
372	  var LAYERS_TEXT_CLASSNAME = 'fa-layers-text';
373	  var FONT_FAMILY_PATTERN = /Font Awesome 5 (Solid|Regular|Light|Brands|Free|Pro)/;
374	  var FONT_WEIGHT_TO_PREFIX = {
375	    '900': 'fas',
376	    '400': 'far',
377	    'normal': 'far',
378	    '300': 'fal'
379	  };
380	  var oneToTen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
381	  var oneToTwenty = oneToTen.concat([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]);
382	  var ATTRIBUTES_WATCHED_FOR_MUTATION = ['class', 'data-prefix', 'data-icon', 'data-fa-transform', 'data-fa-mask'];
383	  var RESERVED_CLASSES = ['xs', 'sm', 'lg', 'fw', 'ul', 'li', 'border', 'pull-left', 'pull-right', 'spin', 'pulse', 'rotate-90', 'rotate-180', 'rotate-270', 'flip-horizontal', 'flip-vertical', 'stack', 'stack-1x', 'stack-2x', 'inverse', 'layers', 'layers-text', 'layers-counter'].concat(oneToTen.map(function (n) {
384	    return "".concat(n, "x");
385	  })).concat(oneToTwenty.map(function (n) {
386	    return "w-".concat(n);
387	  }));
388
389	  var initial = WINDOW.FontAwesomeConfig || {};
390
391	  function getAttrConfig(attr) {
392	    var element = DOCUMENT.querySelector('script[' + attr + ']');
393
394	    if (element) {
395	      return element.getAttribute(attr);
396	    }
397	  }
398
399	  function coerce(val) {
400	    // Getting an empty string will occur if the attribute is set on the HTML tag but without a value
401	    // We'll assume that this is an indication that it should be toggled to true
402	    // For example <script data-search-pseudo-elements src="..."></script>
403	    if (val === '') return true;
404	    if (val === 'false') return false;
405	    if (val === 'true') return true;
406	    return val;
407	  }
408
409	  if (DOCUMENT && typeof DOCUMENT.querySelector === 'function') {
410	    var attrs = [['data-family-prefix', 'familyPrefix'], ['data-replacement-class', 'replacementClass'], ['data-auto-replace-svg', 'autoReplaceSvg'], ['data-auto-add-css', 'autoAddCss'], ['data-auto-a11y', 'autoA11y'], ['data-search-pseudo-elements', 'searchPseudoElements'], ['data-observe-mutations', 'observeMutations'], ['data-keep-original-source', 'keepOriginalSource'], ['data-measure-performance', 'measurePerformance'], ['data-show-missing-icons', 'showMissingIcons']];
411	    attrs.forEach(function (_ref) {
412	      var _ref2 = _slicedToArray(_ref, 2),
413	          attr = _ref2[0],
414	          key = _ref2[1];
415
416	      var val = coerce(getAttrConfig(attr));
417
418	      if (val !== undefined && val !== null) {
419	        initial[key] = val;
420	      }
421	    });
422	  }
423
424	  var _default = {
425	    familyPrefix: DEFAULT_FAMILY_PREFIX,
426	    replacementClass: DEFAULT_REPLACEMENT_CLASS,
427	    autoReplaceSvg: true,
428	    autoAddCss: true,
429	    autoA11y: true,
430	    searchPseudoElements: false,
431	    observeMutations: false,
432	    keepOriginalSource: true,
433	    measurePerformance: false,
434	    showMissingIcons: true
435	  };
436
437	  var _config = _objectSpread({}, _default, initial);
438
439	  if (!_config.autoReplaceSvg) _config.observeMutations = false;
440
441	  var config = _objectSpread({}, _config);
442
443	  WINDOW.FontAwesomeConfig = config;
444
445	  var w = WINDOW || {};
446	  if (!w[NAMESPACE_IDENTIFIER]) w[NAMESPACE_IDENTIFIER] = {};
447	  if (!w[NAMESPACE_IDENTIFIER].styles) w[NAMESPACE_IDENTIFIER].styles = {};
448	  if (!w[NAMESPACE_IDENTIFIER].hooks) w[NAMESPACE_IDENTIFIER].hooks = {};
449	  if (!w[NAMESPACE_IDENTIFIER].shims) w[NAMESPACE_IDENTIFIER].shims = [];
450	  var namespace = w[NAMESPACE_IDENTIFIER];
451
452	  var functions = [];
453
454	  var listener = function listener() {
455	    DOCUMENT.removeEventListener('DOMContentLoaded', listener);
456	    loaded = 1;
457	    functions.map(function (fn) {
458	      return fn();
459	    });
460	  };
461
462	  var loaded = false;
463
464	  if (IS_DOM) {
465	    loaded = (DOCUMENT.documentElement.doScroll ? /^loaded|^c/ : /^loaded|^i|^c/).test(DOCUMENT.readyState);
466	    if (!loaded) DOCUMENT.addEventListener('DOMContentLoaded', listener);
467	  }
468
469	  function domready (fn) {
470	    if (!IS_DOM) return;
471	    loaded ? setTimeout(fn, 0) : functions.push(fn);
472	  }
473
474	  var PENDING = 'pending';
475	  var SETTLED = 'settled';
476	  var FULFILLED = 'fulfilled';
477	  var REJECTED = 'rejected';
478
479	  var NOOP = function NOOP() {};
480
481	  var isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function';
482	  var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
483	  var asyncQueue = [];
484	  var asyncTimer;
485
486	  function asyncFlush() {
487	    // run promise callbacks
488	    for (var i = 0; i < asyncQueue.length; i++) {
489	      asyncQueue[i][0](asyncQueue[i][1]);
490	    } // reset async asyncQueue
491
492
493	    asyncQueue = [];
494	    asyncTimer = false;
495	  }
496
497	  function asyncCall(callback, arg) {
498	    asyncQueue.push([callback, arg]);
499
500	    if (!asyncTimer) {
501	      asyncTimer = true;
502	      asyncSetTimer(asyncFlush, 0);
503	    }
504	  }
505
506	  function invokeResolver(resolver, promise) {
507	    function resolvePromise(value) {
508	      resolve(promise, value);
509	    }
510
511	    function rejectPromise(reason) {
512	      reject(promise, reason);
513	    }
514
515	    try {
516	      resolver(resolvePromise, rejectPromise);
517	    } catch (e) {
518	      rejectPromise(e);
519	    }
520	  }
521
522	  function invokeCallback(subscriber) {
523	    var owner = subscriber.owner;
524	    var settled = owner._state;
525	    var value = owner._data;
526	    var callback = subscriber[settled];
527	    var promise = subscriber.then;
528
529	    if (typeof callback === 'function') {
530	      settled = FULFILLED;
531
532	      try {
533	        value = callback(value);
534	      } catch (e) {
535	        reject(promise, e);
536	      }
537	    }
538
539	    if (!handleThenable(promise, value)) {
540	      if (settled === FULFILLED) {
541	        resolve(promise, value);
542	      }
543
544	      if (settled === REJECTED) {
545	        reject(promise, value);
546	      }
547	    }
548	  }
549
550	  function handleThenable(promise, value) {
551	    var resolved;
552
553	    try {
554	      if (promise === value) {
555	        throw new TypeError('A promises callback cannot return that same promise.');
556	      }
557
558	      if (value && (typeof value === 'function' || _typeof(value) === 'object')) {
559	        // then should be retrieved only once
560	        var then = value.then;
561
562	        if (typeof then === 'function') {
563	          then.call(value, function (val) {
564	            if (!resolved) {
565	              resolved = true;
566
567	              if (value === val) {
568	                fulfill(promise, val);
569	              } else {
570	                resolve(promise, val);
571	              }
572	            }
573	          }, function (reason) {
574	            if (!resolved) {
575	              resolved = true;
576	              reject(promise, reason);
577	            }
578	          });
579	          return true;
580	        }
581	      }
582	    } catch (e) {
583	      if (!resolved) {
584	        reject(promise, e);
585	      }
586
587	      return true;
588	    }
589
590	    return false;
591	  }
592
593	  function resolve(promise, value) {
594	    if (promise === value || !handleThenable(promise, value)) {
595	      fulfill(promise, value);
596	    }
597	  }
598
599	  function fulfill(promise, value) {
600	    if (promise._state === PENDING) {
601	      promise._state = SETTLED;
602	      promise._data = value;
603	      asyncCall(publishFulfillment, promise);
604	    }
605	  }
606
607	  function reject(promise, reason) {
608	    if (promise._state === PENDING) {
609	      promise._state = SETTLED;
610	      promise._data = reason;
611	      asyncCall(publishRejection, promise);
612	    }
613	  }
614
615	  function publish(promise) {
616	    promise._then = promise._then.forEach(invokeCallback);
617	  }
618
619	  function publishFulfillment(promise) {
620	    promise._state = FULFILLED;
621	    publish(promise);
622	  }
623
624	  function publishRejection(promise) {
625	    promise._state = REJECTED;
626	    publish(promise);
627
628	    if (!promise._handled && isNode) {
629	      global.process.emit('unhandledRejection', promise._data, promise);
630	    }
631	  }
632
633	  function notifyRejectionHandled(promise) {
634	    global.process.emit('rejectionHandled', promise);
635	  }
636	  /**
637	   * @class
638	   */
639
640
641	  function P(resolver) {
642	    if (typeof resolver !== 'function') {
643	      throw new TypeError('Promise resolver ' + resolver + ' is not a function');
644	    }
645
646	    if (this instanceof P === false) {
647	      throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
648	    }
649
650	    this._then = [];
651	    invokeResolver(resolver, this);
652	  }
653
654	  P.prototype = {
655	    constructor: P,
656	    _state: PENDING,
657	    _then: null,
658	    _data: undefined,
659	    _handled: false,
660	    then: function then(onFulfillment, onRejection) {
661	      var subscriber = {
662	        owner: this,
663	        then: new this.constructor(NOOP),
664	        fulfilled: onFulfillment,
665	        rejected: onRejection
666	      };
667
668	      if ((onRejection || onFulfillment) && !this._handled) {
669	        this._handled = true;
670
671	        if (this._state === REJECTED && isNode) {
672	          asyncCall(notifyRejectionHandled, this);
673	        }
674	      }
675
676	      if (this._state === FULFILLED || this._state === REJECTED) {
677	        // already resolved, call callback async
678	        asyncCall(invokeCallback, subscriber);
679	      } else {
680	        // subscribe
681	        this._then.push(subscriber);
682	      }
683
684	      return subscriber.then;
685	    },
686	    catch: function _catch(onRejection) {
687	      return this.then(null, onRejection);
688	    }
689	  };
690
691	  P.all = function (promises) {
692	    if (!Array.isArray(promises)) {
693	      throw new TypeError('You must pass an array to Promise.all().');
694	    }
695
696	    return new P(function (resolve, reject) {
697	      var results = [];
698	      var remaining = 0;
699
700	      function resolver(index) {
701	        remaining++;
702	        return function (value) {
703	          results[index] = value;
704
705	          if (! --remaining) {
706	            resolve(results);
707	          }
708	        };
709	      }
710
711	      for (var i = 0, promise; i < promises.length; i++) {
712	        promise = promises[i];
713
714	        if (promise && typeof promise.then === 'function') {
715	          promise.then(resolver(i), reject);
716	        } else {
717	          results[i] = promise;
718	        }
719	      }
720
721	      if (!remaining) {
722	        resolve(results);
723	      }
724	    });
725	  };
726
727	  P.race = function (promises) {
728	    if (!Array.isArray(promises)) {
729	      throw new TypeError('You must pass an array to Promise.race().');
730	    }
731
732	    return new P(function (resolve, reject) {
733	      for (var i = 0, promise; i < promises.length; i++) {
734	        promise = promises[i];
735
736	        if (promise && typeof promise.then === 'function') {
737	          promise.then(resolve, reject);
738	        } else {
739	          resolve(promise);
740	        }
741	      }
742	    });
743	  };
744
745	  P.resolve = function (value) {
746	    if (value && _typeof(value) === 'object' && value.constructor === P) {
747	      return value;
748	    }
749
750	    return new P(function (resolve) {
751	      resolve(value);
752	    });
753	  };
754
755	  P.reject = function (reason) {
756	    return new P(function (resolve, reject) {
757	      reject(reason);
758	    });
759	  };
760
761	  var picked = typeof Promise === 'function' ? Promise : P;
762
763	  var d = UNITS_IN_GRID;
764	  var meaninglessTransform = {
765	    size: 16,
766	    x: 0,
767	    y: 0,
768	    rotate: 0,
769	    flipX: false,
770	    flipY: false
771	  };
772
773	  function isReserved(name) {
774	    return ~RESERVED_CLASSES.indexOf(name);
775	  }
776	  function insertCss(css) {
777	    if (!css || !IS_DOM) {
778	      return;
779	    }
780
781	    var style = DOCUMENT.createElement('style');
782	    style.setAttribute('type', 'text/css');
783	    style.innerHTML = css;
784	    var headChildren = DOCUMENT.head.childNodes;
785	    var beforeChild = null;
786
787	    for (var i = headChildren.length - 1; i > -1; i--) {
788	      var child = headChildren[i];
789	      var tagName = (child.tagName || '').toUpperCase();
790
791	      if (['STYLE', 'LINK'].indexOf(tagName) > -1) {
792	        beforeChild = child;
793	      }
794	    }
795
796	    DOCUMENT.head.insertBefore(style, beforeChild);
797	    return css;
798	  }
799	  var idPool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
800	  function nextUniqueId() {
801	    var size = 12;
802	    var id = '';
803
804	    while (size-- > 0) {
805	      id += idPool[Math.random() * 62 | 0];
806	    }
807
808	    return id;
809	  }
810	  function toArray(obj) {
811	    var array = [];
812
813	    for (var i = (obj || []).length >>> 0; i--;) {
814	      array[i] = obj[i];
815	    }
816
817	    return array;
818	  }
819	  function classArray(node) {
820	    if (node.classList) {
821	      return toArray(node.classList);
822	    } else {
823	      return (node.getAttribute('class') || '').split(' ').filter(function (i) {
824	        return i;
825	      });
826	    }
827	  }
828	  function getIconName(familyPrefix, cls) {
829	    var parts = cls.split('-');
830	    var prefix = parts[0];
831	    var iconName = parts.slice(1).join('-');
832
833	    if (prefix === familyPrefix && iconName !== '' && !isReserved(iconName)) {
834	      return iconName;
835	    } else {
836	      return null;
837	    }
838	  }
839	  function htmlEscape(str) {
840	    return "".concat(str).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
841	  }
842	  function joinAttributes(attributes) {
843	    return Object.keys(attributes || {}).reduce(function (acc, attributeName) {
844	      return acc + "".concat(attributeName, "=\"").concat(htmlEscape(attributes[attributeName]), "\" ");
845	    }, '').trim();
846	  }
847	  function joinStyles(styles) {
848	    return Object.keys(styles || {}).reduce(function (acc, styleName) {
849	      return acc + "".concat(styleName, ": ").concat(styles[styleName], ";");
850	    }, '');
851	  }
852	  function transformIsMeaningful(transform) {
853	    return transform.size !== meaninglessTransform.size || transform.x !== meaninglessTransform.x || transform.y !== meaninglessTransform.y || transform.rotate !== meaninglessTransform.rotate || transform.flipX || transform.flipY;
854	  }
855	  function transformForSvg(_ref) {
856	    var transform = _ref.transform,
857	        containerWidth = _ref.containerWidth,
858	        iconWidth = _ref.iconWidth;
859	    var outer = {
860	      transform: "translate(".concat(containerWidth / 2, " 256)")
861	    };
862	    var innerTranslate = "translate(".concat(transform.x * 32, ", ").concat(transform.y * 32, ") ");
863	    var innerScale = "scale(".concat(transform.size / 16 * (transform.flipX ? -1 : 1), ", ").concat(transform.size / 16 * (transform.flipY ? -1 : 1), ") ");
864	    var innerRotate = "rotate(".concat(transform.rotate, " 0 0)");
865	    var inner = {
866	      transform: "".concat(innerTranslate, " ").concat(innerScale, " ").concat(innerRotate)
867	    };
868	    var path = {
869	      transform: "translate(".concat(iconWidth / 2 * -1, " -256)")
870	    };
871	    return {
872	      outer: outer,
873	      inner: inner,
874	      path: path
875	    };
876	  }
877	  function transformForCss(_ref2) {
878	    var transform = _ref2.transform,
879	        _ref2$width = _ref2.width,
880	        width = _ref2$width === void 0 ? UNITS_IN_GRID : _ref2$width,
881	        _ref2$height = _ref2.height,
882	        height = _ref2$height === void 0 ? UNITS_IN_GRID : _ref2$height,
883	        _ref2$startCentered = _ref2.startCentered,
884	        startCentered = _ref2$startCentered === void 0 ? false : _ref2$startCentered;
885	    var val = '';
886
887	    if (startCentered && IS_IE) {
888	      val += "translate(".concat(transform.x / d - width / 2, "em, ").concat(transform.y / d - height / 2, "em) ");
889	    } else if (startCentered) {
890	      val += "translate(calc(-50% + ".concat(transform.x / d, "em), calc(-50% + ").concat(transform.y / d, "em)) ");
891	    } else {
892	      val += "translate(".concat(transform.x / d, "em, ").concat(transform.y / d, "em) ");
893	    }
894
895	    val += "scale(".concat(transform.size / d * (transform.flipX ? -1 : 1), ", ").concat(transform.size / d * (transform.flipY ? -1 : 1), ") ");
896	    val += "rotate(".concat(transform.rotate, "deg) ");
897	    return val;
898	  }
899
900	  var ALL_SPACE = {
901	    x: 0,
902	    y: 0,
903	    width: '100%',
904	    height: '100%'
905	  };
906	  function makeIconMasking (_ref) {
907	    var children = _ref.children,
908	        attributes = _ref.attributes,
909	        main = _ref.main,
910	        mask = _ref.mask,
911	        transform = _ref.transform;
912	    var mainWidth = main.width,
913	        mainPath = main.icon;
914	    var maskWidth = mask.width,
915	        maskPath = mask.icon;
916	    var trans = transformForSvg({
917	      transform: transform,
918	      containerWidth: maskWidth,
919	      iconWidth: mainWidth
920	    });
921	    var maskRect = {
922	      tag: 'rect',
923	      attributes: _objectSpread({}, ALL_SPACE, {
924	        fill: 'white'
925	      })
926	    };
927	    var maskInnerGroup = {
928	      tag: 'g',
929	      attributes: _objectSpread({}, trans.inner),
930	      children: [{
931	        tag: 'path',
932	        attributes: _objectSpread({}, mainPath.attributes, trans.path, {
933	          fill: 'black'
934	        })
935	      }]
936	    };
937	    var maskOuterGroup = {
938	      tag: 'g',
939	      attributes: _objectSpread({}, trans.outer),
940	      children: [maskInnerGroup]
941	    };
942	    var maskId = "mask-".concat(nextUniqueId());
943	    var clipId = "clip-".concat(nextUniqueId());
944	    var maskTag = {
945	      tag: 'mask',
946	      attributes: _objectSpread({}, ALL_SPACE, {
947	        id: maskId,
948	        maskUnits: 'userSpaceOnUse',
949	        maskContentUnits: 'userSpaceOnUse'
950	      }),
951	      children: [maskRect, maskOuterGroup]
952	    };
953	    var defs = {
954	      tag: 'defs',
955	      children: [{
956	        tag: 'clipPath',
957	        attributes: {
958	          id: clipId
959	        },
960	        children: [maskPath]
961	      }, maskTag]
962	    };
963	    children.push(defs, {
964	      tag: 'rect',
965	      attributes: _objectSpread({
966	        fill: 'currentColor',
967	        'clip-path': "url(#".concat(clipId, ")"),
968	        mask: "url(#".concat(maskId, ")")
969	      }, ALL_SPACE)
970	    });
971	    return {
972	      children: children,
973	      attributes: attributes
974	    };
975	  }
976
977	  function makeIconStandard (_ref) {
978	    var children = _ref.children,
979	        attributes = _ref.attributes,
980	        main = _ref.main,
981	        transform = _ref.transform,
982	        styles = _ref.styles;
983	    var styleString = joinStyles(styles);
984
985	    if (styleString.length > 0) {
986	      attributes['style'] = styleString;
987	    }
988
989	    if (transformIsMeaningful(transform)) {
990	      var trans = transformForSvg({
991	        transform: transform,
992	        containerWidth: main.width,
993	        iconWidth: main.width
994	      });
995	      children.push({
996	        tag: 'g',
997	        attributes: _objectSpread({}, trans.outer),
998	        children: [{
999	          tag: 'g',
1000	          attributes: _objectSpread({}, trans.inner),
1001	          children: [{
1002	            tag: main.icon.tag,
1003	            children: main.icon.children,
1004	            attributes: _objectSpread({}, main.icon.attributes, trans.path)
1005	          }]
1006	        }]
1007	      });
1008	    } else {
1009	      children.push(main.icon);
1010	    }
1011
1012	    return {
1013	      children: children,
1014	      attributes: attributes
1015	    };
1016	  }
1017
1018	  function asIcon (_ref) {
1019	    var children = _ref.children,
1020	        main = _ref.main,
1021	        mask = _ref.mask,
1022	        attributes = _ref.attributes,
1023	        styles = _ref.styles,
1024	        transform = _ref.transform;
1025
1026	    if (transformIsMeaningful(transform) && main.found && !mask.found) {
1027	      var width = main.width,
1028	          height = main.height;
1029	      var offset = {
1030	        x: width / height / 2,
1031	        y: 0.5
1032	      };
1033	      attributes['style'] = joinStyles(_objectSpread({}, styles, {
1034	        'transform-origin': "".concat(offset.x + transform.x / 16, "em ").concat(offset.y + transform.y / 16, "em")
1035	      }));
1036	    }
1037
1038	    return [{
1039	      tag: 'svg',
1040	      attributes: attributes,
1041	      children: children
1042	    }];
1043	  }
1044
1045	  function asSymbol (_ref) {
1046	    var prefix = _ref.prefix,
1047	        iconName = _ref.iconName,
1048	        children = _ref.children,
1049	        attributes = _ref.attributes,
1050	        symbol = _ref.symbol;
1051	    var id = symbol === true ? "".concat(prefix, "-").concat(config.familyPrefix, "-").concat(iconName) : symbol;
1052	    return [{
1053	      tag: 'svg',
1054	      attributes: {
1055	        style: 'display: none;'
1056	      },
1057	      children: [{
1058	        tag: 'symbol',
1059	        attributes: _objectSpread({}, attributes, {
1060	          id: id
1061	        }),
1062	        children: children
1063	      }]
1064	    }];
1065	  }
1066
1067	  function makeInlineSvgAbstract(params) {
1068	    var _params$icons = params.icons,
1069	        main = _params$icons.main,
1070	        mask = _params$icons.mask,
1071	        prefix = params.prefix,
1072	        iconName = params.iconName,
1073	        transform = params.transform,
1074	        symbol = params.symbol,
1075	        title = params.title,
1076	        extra = params.extra,
1077	        _params$watchable = params.watchable,
1078	        watchable = _params$watchable === void 0 ? false : _params$watchable;
1079
1080	    var _ref = mask.found ? mask : main,
1081	        width = _ref.width,
1082	        height = _ref.height;
1083
1084	    var widthClass = "fa-w-".concat(Math.ceil(width / height * 16));
1085	    var attrClass = [config.replacementClass, iconName ? "".concat(config.familyPrefix, "-").concat(iconName) : '', widthClass].filter(function (c) {
1086	      return extra.classes.indexOf(c) === -1;
1087	    }).concat(extra.classes).join(' ');
1088	    var content = {
1089	      children: [],
1090	      attributes: _objectSpread({}, extra.attributes, {
1091	        'data-prefix': prefix,
1092	        'data-icon': iconName,
1093	        'class': attrClass,
1094	        'role': 'img',
1095	        'xmlns': 'http://www.w3.org/2000/svg',
1096	        'viewBox': "0 0 ".concat(width, " ").concat(height)
1097	      })
1098	    };
1099
1100	    if (watchable) {
1101	      content.attributes[DATA_FA_I2SVG] = '';
1102	    }
1103
1104	    if (title) content.children.push({
1105	      tag: 'title',
1106	      attributes: {
1107	        id: content.attributes['aria-labelledby'] || "title-".concat(nextUniqueId())
1108	      },
1109	      children: [title]
1110	    });
1111
1112	    var args = _objectSpread({}, content, {
1113	      prefix: prefix,
1114	      iconName: iconName,
1115	      main: main,
1116	      mask: mask,
1117	      transform: transform,
1118	      symbol: symbol,
1119	      styles: extra.styles
1120	    });
1121
1122	    var _ref2 = mask.found && main.found ? makeIconMasking(args) : makeIconStandard(args),
1123	        children = _ref2.children,
1124	        attributes = _ref2.attributes;
1125
1126	    args.children = children;
1127	    args.attributes = attributes;
1128
1129	    if (symbol) {
1130	      return asSymbol(args);
1131	    } else {
1132	      return asIcon(args);
1133	    }
1134	  }
1135	  function makeLayersTextAbstract(params) {
1136	    var content = params.content,
1137	        width = params.width,
1138	        height = params.height,
1139	        transform = params.transform,
1140	        title = params.title,
1141	        extra = params.extra,
1142	        _params$watchable2 = params.watchable,
1143	        watchable = _params$watchable2 === void 0 ? false : _params$watchable2;
1144
1145	    var attributes = _objectSpread({}, extra.attributes, title ? {
1146	      'title': title
1147	    } : {}, {
1148	      'class': extra.classes.join(' ')
1149	    });
1150
1151	    if (watchable) {
1152	      attributes[DATA_FA_I2SVG] = '';
1153	    }
1154
1155	    var styles = _objectSpread({}, extra.styles);
1156
1157	    if (transformIsMeaningful(transform)) {
1158	      styles['transform'] = transformForCss({
1159	        transform: transform,
1160	        startCentered: true,
1161	        width: width,
1162	        height: height
1163	      });
1164	      styles['-webkit-transform'] = styles['transform'];
1165	    }
1166
1167	    var styleString = joinStyles(styles);
1168
1169	    if (styleString.length > 0) {
1170	      attributes['style'] = styleString;
1171	    }
1172
1173	    var val = [];
1174	    val.push({
1175	      tag: 'span',
1176	      attributes: attributes,
1177	      children: [content]
1178	    });
1179
1180	    if (title) {
1181	      val.push({
1182	        tag: 'span',
1183	        attributes: {
1184	          class: 'sr-only'
1185	        },
1186	        children: [title]
1187	      });
1188	    }
1189
1190	    return val;
1191	  }
1192	  function makeLayersCounterAbstract(params) {
1193	    var content = params.content,
1194	        title = params.title,
1195	        extra = params.extra;
1196
1197	    var attributes = _objectSpread({}, extra.attributes, title ? {
1198	      'title': title
1199	    } : {}, {
1200	      'class': extra.classes.join(' ')
1201	    });
1202
1203	    var styleString = joinStyles(extra.styles);
1204
1205	    if (styleString.length > 0) {
1206	      attributes['style'] = styleString;
1207	    }
1208
1209	    var val = [];
1210	    val.push({
1211	      tag: 'span',
1212	      attributes: attributes,
1213	      children: [content]
1214	    });
1215
1216	    if (title) {
1217	      val.push({
1218	        tag: 'span',
1219	        attributes: {
1220	          class: 'sr-only'
1221	        },
1222	        children: [title]
1223	      });
1224	    }
1225
1226	    return val;
1227	  }
1228
1229	  var noop$1 = function noop() {};
1230
1231	  var p = config.measurePerformance && PERFORMANCE && PERFORMANCE.mark && PERFORMANCE.measure ? PERFORMANCE : {
1232	    mark: noop$1,
1233	    measure: noop$1
1234	  };
1235	  var preamble = "FA \"5.7.2\"";
1236
1237	  var begin = function begin(name) {
1238	    p.mark("".concat(preamble, " ").concat(name, " begins"));
1239	    return function () {
1240	      return end(name);
1241	    };
1242	  };
1243
1244	  var end = function end(name) {
1245	    p.mark("".concat(preamble, " ").concat(name, " ends"));
1246	    p.measure("".concat(preamble, " ").concat(name), "".concat(preamble, " ").concat(name, " begins"), "".concat(preamble, " ").concat(name, " ends"));
1247	  };
1248
1249	  var perf = {
1250	    begin: begin,
1251	    end: end
1252	  };
1253
1254	  /**
1255	   * Internal helper to bind a function known to have 4 arguments
1256	   * to a given context.
1257	   */
1258
1259	  var bindInternal4 = function bindInternal4(func, thisContext) {
1260	    return function (a, b, c, d) {
1261	      return func.call(thisContext, a, b, c, d);
1262	    };
1263	  };
1264
1265	  /**
1266	   * # Reduce
1267	   *
1268	   * A fast object `.reduce()` implementation.
1269	   *
1270	   * @param  {Object}   subject      The object to reduce over.
1271	   * @param  {Function} fn           The reducer function.
1272	   * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
1273	   * @param  {Object}   thisContext  The context for the reducer.
1274	   * @return {mixed}                 The final result.
1275	   */
1276
1277
1278	  var reduce = function fastReduceObject(subject, fn, initialValue, thisContext) {
1279	    var keys = Object.keys(subject),
1280	        length = keys.length,
1281	        iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
1282	        i,
1283	        key,
1284	        result;
1285
1286	    if (initialValue === undefined) {
1287	      i = 1;
1288	      result = subject[keys[0]];
1289	    } else {
1290	      i = 0;
1291	      result = initialValue;
1292	    }
1293
1294	    for (; i < length; i++) {
1295	      key = keys[i];
1296	      result = iterator(result, subject[key], key, subject);
1297	    }
1298
1299	    return result;
1300	  };
1301
1302	  function defineIcons(prefix, icons) {
1303	    var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
1304	    var _params$skipHooks = params.skipHooks,
1305	        skipHooks = _params$skipHooks === void 0 ? false : _params$skipHooks;
1306	    var normalized = Object.keys(icons).reduce(function (acc, iconName) {
1307	      var icon = icons[iconName];
1308	      var expanded = !!icon.icon;
1309
1310	      if (expanded) {
1311	        acc[icon.iconName] = icon.icon;
1312	      } else {
1313	        acc[iconName] = icon;
1314	      }
1315
1316	      return acc;
1317	    }, {});
1318
1319	    if (typeof namespace.hooks.addPack === 'function' && !skipHooks) {
1320	      namespace.hooks.addPack(prefix, normalized);
1321	    } else {
1322	      namespace.styles[prefix] = _objectSpread({}, namespace.styles[prefix] || {}, normalized);
1323	    }
1324	    /**
1325	     * Font Awesome 4 used the prefix of `fa` for all icons. With the introduction
1326	     * of new styles we needed to differentiate between them. Prefix `fa` is now an alias
1327	     * for `fas` so we'll easy the upgrade process for our users by automatically defining
1328	     * this as well.
1329	     */
1330
1331
1332	    if (prefix === 'fas') {
1333	      defineIcons('fa', icons);
1334	    }
1335	  }
1336
1337	  var styles = namespace.styles,
1338	      shims = namespace.shims;
1339	  var _byUnicode = {};
1340	  var _byLigature = {};
1341	  var _byOldName = {};
1342	  var build = function build() {
1343	    var lookup = function lookup(reducer) {
1344	      return reduce(styles, function (o, style, prefix) {
1345	        o[prefix] = reduce(style, reducer, {});
1346	        return o;
1347	      }, {});
1348	    };
1349
1350	    _byUnicode = lookup(function (acc, icon, iconName) {
1351	      if (icon[3]) {
1352	        acc[icon[3]] = iconName;
1353	      }
1354
1355	      return acc;
1356	    });
1357	    _byLigature = lookup(function (acc, icon, iconName) {
1358	      var ligatures = icon[2];
1359	      acc[iconName] = iconName;
1360	      ligatures.forEach(function (ligature) {
1361	        acc[ligature] = iconName;
1362	      });
1363	      return acc;
1364	    });
1365	    var hasRegular = 'far' in styles;
1366	    _byOldName = reduce(shims, function (acc, shim) {
1367	      var oldName = shim[0];
1368	      var prefix = shim[1];
1369	      var iconName = shim[2];
1370
1371	      if (prefix === 'far' && !hasRegular) {
1372	        prefix = 'fas';
1373	      }
1374
1375	      acc[oldName] = {
1376	        prefix: prefix,
1377	        iconName: iconName
1378	      };
1379	      return acc;
1380	    }, {});
1381	  };
1382	  build();
1383	  function byUnicode(prefix, unicode) {
1384	    return _byUnicode[prefix][unicode];
1385	  }
1386	  function byLigature(prefix, ligature) {
1387	    return _byLigature[prefix][ligature];
1388	  }
1389	  function byOldName(name) {
1390	    return _byOldName[name] || {
1391	      prefix: null,
1392	      iconName: null
1393	    };
1394	  }
1395
1396	  var styles$1 = namespace.styles;
1397	  var emptyCanonicalIcon = function emptyCanonicalIcon() {
1398	    return {
1399	      prefix: null,
1400	      iconName: null,
1401	      rest: []
1402	    };
1403	  };
1404	  function getCanonicalIcon(values) {
1405	    return values.reduce(function (acc, cls) {
1406	      var iconName = getIconName(config.familyPrefix, cls);
1407
1408	      if (styles$1[cls]) {
1409	        acc.prefix = cls;
1410	      } else if (config.autoFetchSvg && ['fas', 'far', 'fal', 'fab', 'fa'].indexOf(cls) > -1) {
1411	        acc.prefix = cls;
1412	      } else if (iconName) {
1413	        var shim = acc.prefix === 'fa' ? byOldName(iconName) : {};
1414	        acc.iconName = shim.iconName || iconName;
1415	        acc.prefix = shim.prefix || acc.prefix;
1416	      } else if (cls !== config.replacementClass && cls.indexOf('fa-w-') !== 0) {
1417	        acc.rest.push(cls);
1418	      }
1419
1420	      return acc;
1421	    }, emptyCanonicalIcon());
1422	  }
1423	  function iconFromMapping(mapping, prefix, iconName) {
1424	    if (mapping && mapping[prefix] && mapping[prefix][iconName]) {
1425	      return {
1426	        prefix: prefix,
1427	        iconName: iconName,
1428	        icon: mapping[prefix][iconName]
1429	      };
1430	    }
1431	  }
1432
1433	  function toHtml(abstractNodes) {
1434	    var tag = abstractNodes.tag,
1435	        _abstractNodes$attrib = abstractNodes.attributes,
1436	        attributes = _abstractNodes$attrib === void 0 ? {} : _abstractNodes$attrib,
1437	        _abstractNodes$childr = abstractNodes.children,
1438	        children = _abstractNodes$childr === void 0 ? [] : _abstractNodes$childr;
1439
1440	    if (typeof abstractNodes === 'string') {
1441	      return htmlEscape(abstractNodes);
1442	    } else {
1443	      return "<".concat(tag, " ").concat(joinAttributes(attributes), ">").concat(children.map(toHtml).join(''), "</").concat(tag, ">");
1444	    }
1445	  }
1446
1447	  var noop$2 = function noop() {};
1448
1449	  function isWatched(node) {
1450	    var i2svg = node.getAttribute ? node.getAttribute(DATA_FA_I2SVG) : null;
1451	    return typeof i2svg === 'string';
1452	  }
1453
1454	  function getMutator() {
1455	    if (config.autoReplaceSvg === true) {
1456	      return mutators.replace;
1457	    }
1458
1459	    var mutator = mutators[config.autoReplaceSvg];
1460	    return mutator || mutators.replace;
1461	  }
1462
1463	  var mutators = {
1464	    replace: function replace(mutation) {
1465	      var node = mutation[0];
1466	      var abstract = mutation[1];
1467	      var newOuterHTML = abstract.map(function (a) {
1468	        return toHtml(a);
1469	      }).join('\n');
1470
1471	      if (node.parentNode && node.outerHTML) {
1472	        node.outerHTML = newOuterHTML + (config.keepOriginalSource && node.tagName.toLowerCase() !== 'svg' ? "<!-- ".concat(node.outerHTML, " -->") : '');
1473	      } else if (node.parentNode) {
1474	        var newNode = document.createElement('span');
1475	        node.parentNode.replaceChild(newNode, node);
1476	        newNode.outerHTML = newOuterHTML;
1477	      }
1478	    },
1479	    nest: function nest(mutation) {
1480	      var node = mutation[0];
1481	      var abstract = mutation[1]; // If we already have a replaced node we do not want to continue nesting within it.
1482	      // Short-circuit to the standard replacement
1483
1484	      if (~classArray(node).indexOf(config.replacementClass)) {
1485	        return mutators.replace(mutation);
1486	      }
1487
1488	      var forSvg = new RegExp("".concat(config.familyPrefix, "-.*"));
1489	      delete abstract[0].attributes.style;
1490	      var splitClasses = abstract[0].attributes.class.split(' ').reduce(function (acc, cls) {
1491	        if (cls === config.replacementClass || cls.match(forSvg)) {
1492	          acc.toSvg.push(cls);
1493	        } else {
1494	          acc.toNode.push(cls);
1495	        }
1496
1497	        return acc;
1498	      }, {
1499	        toNode: [],
1500	        toSvg: []
1501	      });
1502	      abstract[0].attributes.class = splitClasses.toSvg.join(' ');
1503	      var newInnerHTML = abstract.map(function (a) {
1504	        return toHtml(a);
1505	      }).join('\n');
1506	      node.setAttribute('class', splitClasses.toNode.join(' '));
1507	      node.setAttribute(DATA_FA_I2SVG, '');
1508	      node.innerHTML = newInnerHTML;
1509	    }
1510	  };
1511	  function perform(mutations, callback) {
1512	    var callbackFunction = typeof callback === 'function' ? callback : noop$2;
1513
1514	    if (mutations.length === 0) {
1515	      callbackFunction();
1516	    } else {
1517	      var frame = WINDOW.requestAnimationFrame || function (op) {
1518	        return op();
1519	      };
1520
1521	      frame(function () {
1522	        var mutator = getMutator();
1523	        var mark = perf.begin('mutate');
1524	        mutations.map(mutator);
1525	        mark();
1526	        callbackFunction();
1527	      });
1528	    }
1529	  }
1530	  var disabled = false;
1531	  function disableObservation() {
1532	    disabled = true;
1533	  }
1534	  function enableObservation() {
1535	    disabled = false;
1536	  }
1537	  var mo = null;
1538	  function observe(options) {
1539	    if (!MUTATION_OBSERVER) {
1540	      return;
1541	    }
1542
1543	    if (!config.observeMutations) {
1544	      return;
1545	    }
1546
1547	    var treeCallback = options.treeCallback,
1548	        nodeCallback = options.nodeCallback,
1549	        pseudoElementsCallback = options.pseudoElementsCallback,
1550	        _options$observeMutat = options.observeMutationsRoot,
1551	        observeMutationsRoot = _options$observeMutat === void 0 ? DOCUMENT : _options$observeMutat;
1552	    mo = new MUTATION_OBSERVER(function (objects) {
1553	      if (disabled) return;
1554	      toArray(objects).forEach(function (mutationRecord) {
1555	        if (mutationRecord.type === 'childList' && mutationRecord.addedNodes.length > 0 && !isWatched(mutationRecord.addedNodes[0])) {
1556	          if (config.searchPseudoElements) {
1557	            pseudoElementsCallback(mutationRecord.target);
1558	          }
1559
1560	          treeCallback(mutationRecord.target);
1561	        }
1562
1563	        if (mutationRecord.type === 'attributes' && mutationRecord.target.parentNode && config.searchPseudoElements) {
1564	          pseudoElementsCallback(mutationRecord.target.parentNode);
1565	        }
1566
1567	        if (mutationRecord.type === 'attributes' && isWatched(mutationRecord.target) && ~ATTRIBUTES_WATCHED_FOR_MUTATION.indexOf(mutationRecord.attributeName)) {
1568	          if (mutationRecord.attributeName === 'class') {
1569	            var _getCanonicalIcon = getCanonicalIcon(classArray(mutationRecord.target)),
1570	                prefix = _getCanonicalIcon.prefix,
1571	                iconName = _getCanonicalIcon.iconName;
1572
1573	            if (prefix) mutationRecord.target.setAttribute('data-prefix', prefix);
1574	            if (iconName) mutationRecord.target.setAttribute('data-icon', iconName);
1575	          } else {
1576	            nodeCallback(mutationRecord.target);
1577	          }
1578	        }
1579	      });
1580	    });
1581	    if (!IS_DOM) return;
1582	    mo.observe(observeMutationsRoot, {
1583	      childList: true,
1584	      attributes: true,
1585	      characterData: true,
1586	      subtree: true
1587	    });
1588	  }
1589	  function disconnect() {
1590	    if (!mo) return;
1591	    mo.disconnect();
1592	  }
1593
1594	  function styleParser (node) {
1595	    var style = node.getAttribute('style');
1596	    var val = [];
1597
1598	    if (style) {
1599	      val = style.split(';').reduce(function (acc, style) {
1600	        var styles = style.split(':');
1601	        var prop = styles[0];
1602	        var value = styles.slice(1);
1603
1604	        if (prop && value.length > 0) {
1605	          acc[prop] = value.join(':').trim();
1606	        }
1607
1608	        return acc;
1609	      }, {});
1610	    }
1611
1612	    return val;
1613	  }
1614
1615	  function toHex(unicode) {
1616	    var result = '';
1617
1618	    for (var i = 0; i < unicode.length; i++) {
1619	      var hex = unicode.charCodeAt(i).toString(16);
1620	      result += ('000' + hex).slice(-4);
1621	    }
1622
1623	    return result;
1624	  }
1625
1626	  function classParser (node) {
1627	    var existingPrefix = node.getAttribute('data-prefix');
1628	    var existingIconName = node.getAttribute('data-icon');
1629	    var innerText = node.innerText !== undefined ? node.innerText.trim() : '';
1630	    var val = getCanonicalIcon(classArray(node));
1631
1632	    if (existingPrefix && existingIconName) {
1633	      val.prefix = existingPrefix;
1634	      val.iconName = existingIconName;
1635	    }
1636
1637	    if (val.prefix && innerText.length > 1) {
1638	      val.iconName = byLigature(val.prefix, node.innerText);
1639	    } else if (val.prefix && innerText.length === 1) {
1640	      val.iconName = byUnicode(val.prefix, toHex(node.innerText));
1641	    }
1642
1643	    return val;
1644	  }
1645
1646	  var parseTransformString = function parseTransformString(transformString) {
1647	    var transform = {
1648	      size: 16,
1649	      x: 0,
1650	      y: 0,
1651	      flipX: false,
1652	      flipY: false,
1653	      rotate: 0
1654	    };
1655
1656	    if (!transformString) {
1657	      return transform;
1658	    } else {
1659	      return transformString.toLowerCase().split(' ').reduce(function (acc, n) {
1660	        var parts = n.toLowerCase().split('-');
1661	        var first = parts[0];
1662	        var rest = parts.slice(1).join('-');
1663
1664	        if (first && rest === 'h') {
1665	          acc.flipX = true;
1666	          return acc;
1667	        }
1668
1669	        if (first && rest === 'v') {
1670	          acc.flipY = true;
1671	          return acc;
1672	        }
1673
1674	        rest = parseFloat(rest);
1675
1676	        if (isNaN(rest)) {
1677	          return acc;
1678	        }
1679
1680	        switch (first) {
1681	          case 'grow':
1682	            acc.size = acc.size + rest;
1683	            break;
1684
1685	          case 'shrink':
1686	            acc.size = acc.size - rest;
1687	            break;
1688
1689	          case 'left':
1690	            acc.x = acc.x - rest;
1691	            break;
1692
1693	          case 'right':
1694	            acc.x = acc.x + rest;
1695	            break;
1696
1697	          case 'up':
1698	            acc.y = acc.y - rest;
1699	            break;
1700
1701	          case 'down':
1702	            acc.y = acc.y + rest;
1703	            break;
1704
1705	          case 'rotate':
1706	            acc.rotate = acc.rotate + rest;
1707	            break;
1708	        }
1709
1710	        return acc;
1711	      }, transform);
1712	    }
1713	  };
1714	  function transformParser (node) {
1715	    return parseTransformString(node.getAttribute('data-fa-transform'));
1716	  }
1717
1718	  function symbolParser (node) {
1719	    var symbol = node.getAttribute('data-fa-symbol');
1720	    return symbol === null ? false : symbol === '' ? true : symbol;
1721	  }
1722
1723	  function attributesParser (node) {
1724	    var extraAttributes = toArray(node.attributes).reduce(function (acc, attr) {
1725	      if (acc.name !== 'class' && acc.name !== 'style') {
1726	        acc[attr.name] = attr.value;
1727	      }
1728
1729	      return acc;
1730	    }, {});
1731	    var title = node.getAttribute('title');
1732
1733	    if (config.autoA11y) {
1734	      if (title) {
1735	        extraAttributes['aria-labelledby'] = "".concat(config.replacementClass, "-title-").concat(nextUniqueId());
1736	      } else {
1737	        extraAttributes['aria-hidden'] = 'true';
1738	        extraAttributes['focusable'] = 'false';
1739	      }
1740	    }
1741
1742	    return extraAttributes;
1743	  }
1744
1745	  function maskParser (node) {
1746	    var mask = node.getAttribute('data-fa-mask');
1747
1748	    if (!mask) {
1749	      return emptyCanonicalIcon();
1750	    } else {
1751	      return getCanonicalIcon(mask.split(' ').map(function (i) {
1752	        return i.trim();
1753	      }));
1754	    }
1755	  }
1756
1757	  function blankMeta() {
1758	    return {
1759	      iconName: null,
1760	      title: null,
1761	      prefix: null,
1762	      transform: meaninglessTransform,
1763	      symbol: false,
1764	      mask: null,
1765	      extra: {
1766	        classes: [],
1767	        styles: {},
1768	        attributes: {}
1769	      }
1770	    };
1771	  }
1772	  function parseMeta(node) {
1773	    var _classParser = classParser(node),
1774	        iconName = _classParser.iconName,
1775	        prefix = _classParser.prefix,
1776	        extraClasses = _classParser.rest;
1777
1778	    var extraStyles = styleParser(node);
1779	    var transform = transformParser(node);
1780	    var symbol = symbolParser(node);
1781	    var extraAttributes = attributesParser(node);
1782	    var mask = maskParser(node);
1783	    return {
1784	      iconName: iconName,
1785	      title: node.getAttribute('title'),
1786	      prefix: prefix,
1787	      transform: transform,
1788	      symbol: symbol,
1789	      mask: mask,
1790	      extra: {
1791	        classes: extraClasses,
1792	        styles: extraStyles,
1793	        attributes: extraAttributes
1794	      }
1795	    };
1796	  }
1797
1798	  function MissingIcon(error) {
1799	    this.name = 'MissingIcon';
1800	    this.message = error || 'Icon unavailable';
1801	    this.stack = new Error().stack;
1802	  }
1803	  MissingIcon.prototype = Object.create(Error.prototype);
1804	  MissingIcon.prototype.constructor = MissingIcon;
1805
1806	  var FILL = {
1807	    fill: 'currentColor'
1808	  };
1809	  var ANIMATION_BASE = {
1810	    attributeType: 'XML',
1811	    repeatCount: 'indefinite',
1812	    dur: '2s'
1813	  };
1814	  var RING = {
1815	    tag: 'path',
1816	    attributes: _objectSpread({}, FILL, {
1817	      d: 'M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z'
1818	    })
1819	  };
1820
1821	  var OPACITY_ANIMATE = _objectSpread({}, ANIMATION_BASE, {
1822	    attributeName: 'opacity'
1823	  });
1824
1825	  var DOT = {
1826	    tag: 'circle',
1827	    attributes: _objectSpread({}, FILL, {
1828	      cx: '256',
1829	      cy: '364',
1830	      r: '28'
1831	    }),
1832	    children: [{
1833	      tag: 'animate',
1834	      attributes: _objectSpread({}, ANIMATION_BASE, {
1835	        attributeName: 'r',
1836	        values: '28;14;28;28;14;28;'
1837	      })
1838	    }, {
1839	      tag: 'animate',
1840	      attributes: _objectSpread({}, OPACITY_ANIMATE, {
1841	        values: '1;0;1;1;0;1;'
1842	      })
1843	    }]
1844	  };
1845	  var QUESTION = {
1846	    tag: 'path',
1847	    attributes: _objectSpread({}, FILL, {
1848	      opacity: '1',
1849	      d: 'M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z'
1850	    }),
1851	    children: [{
1852	      tag: 'animate',
1853	      attributes: _objectSpread({}, OPACITY_ANIMATE, {
1854	        values: '1;0;0;0;0;1;'
1855	      })
1856	    }]
1857	  };
1858	  var EXCLAMATION = {
1859	    tag: 'path',
1860	    attributes: _objectSpread({}, FILL, {
1861	      opacity: '0',
1862	      d: 'M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z'
1863	    }),
1864	    children: [{
1865	      tag: 'animate',
1866	      attributes: _objectSpread({}, OPACITY_ANIMATE, {
1867	        values: '0;0;1;1;0;0;'
1868	      })
1869	    }]
1870	  };
1871	  var missing = {
1872	    tag: 'g',
1873	    children: [RING, DOT, QUESTION, EXCLAMATION]
1874	  };
1875
1876	  var styles$2 = namespace.styles;
1877	  function findIcon(iconName, prefix) {
1878	    return new picked(function (resolve, reject) {
1879	      var val = {
1880	        found: false,
1881	        width: 512,
1882	        height: 512,
1883	        icon: missing
1884	      };
1885
1886	      if (iconName && prefix && styles$2[prefix] && styles$2[prefix][iconName]) {
1887	        var icon = styles$2[prefix][iconName];
1888	        var width = icon[0];
1889	        var height = icon[1];
1890	        var vectorData = icon.slice(4);
1891	        val = {
1892	          found: true,
1893	          width: width,
1894	          height: height,
1895	          icon: {
1896	            tag: 'path',
1897	            attributes: {
1898	              fill: 'currentColor',
1899	              d: vectorData[0]
1900	            }
1901	          }
1902	        };
1903	        return resolve(val);
1904	      }
1905
1906	      if (iconName && prefix && !config.showMissingIcons) {
1907	        reject(new MissingIcon("Icon is missing for prefix ".concat(prefix, " with icon name ").concat(iconName)));
1908	      } else {
1909	        resolve(val);
1910	      }
1911	    });
1912	  }
1913
1914	  var styles$3 = namespace.styles;
1915
1916	  function generateSvgReplacementMutation(node, nodeMeta) {
1917	    var iconName = nodeMeta.iconName,
1918	        title = nodeMeta.title,
1919	        prefix = nodeMeta.prefix,
1920	        transform = nodeMeta.transform,
1921	        symbol = nodeMeta.symbol,
1922	        mask = nodeMeta.mask,
1923	        extra = nodeMeta.extra;
1924	    return new picked(function (resolve, reject) {
1925	      picked.all([findIcon(iconName, prefix), findIcon(mask.iconName, mask.prefix)]).then(function (_ref) {
1926	        var _ref2 = _slicedToArray(_ref, 2),
1927	            main = _ref2[0],
1928	            mask = _ref2[1];
1929
1930	        resolve([node, makeInlineSvgAbstract({
1931	          icons: {
1932	            main: main,
1933	            mask: mask
1934	          },
1935	          prefix: prefix,
1936	          iconName: iconName,
1937	          transform: transform,
1938	          symbol: symbol,
1939	          mask: mask,
1940	          title: title,
1941	          extra: extra,
1942	          watchable: true
1943	        })]);
1944	      });
1945	    });
1946	  }
1947
1948	  function generateLayersText(node, nodeMeta) {
1949	    var title = nodeMeta.title,
1950	        transform = nodeMeta.transform,
1951	        extra = nodeMeta.extra;
1952	    var width = null;
1953	    var height = null;
1954
1955	    if (IS_IE) {
1956	      var computedFontSize = parseInt(getComputedStyle(node).fontSize, 10);
1957	      var boundingClientRect = node.getBoundingClientRect();
1958	      width = boundingClientRect.width / computedFontSize;
1959	      height = boundingClientRect.height / computedFontSize;
1960	    }
1961
1962	    if (config.autoA11y && !title) {
1963	      extra.attributes['aria-hidden'] = 'true';
1964	    }
1965
1966	    return picked.resolve([node, makeLayersTextAbstract({
1967	      content: node.innerHTML,
1968	      width: width,
1969	      height: height,
1970	      transform: transform,
1971	      title: title,
1972	      extra: extra,
1973	      watchable: true
1974	    })]);
1975	  }
1976
1977	  function generateMutation(node) {
1978	    var nodeMeta = parseMeta(node);
1979
1980	    if (~nodeMeta.extra.classes.indexOf(LAYERS_TEXT_CLASSNAME)) {
1981	      return generateLayersText(node, nodeMeta);
1982	    } else {
1983	      return generateSvgReplacementMutation(node, nodeMeta);
1984	    }
1985	  }
1986
1987	  function onTree(root) {
1988	    var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
1989	    if (!IS_DOM) return;
1990	    var htmlClassList = DOCUMENT.documentElement.classList;
1991
1992	    var hclAdd = function hclAdd(suffix) {
1993	      return htmlClassList.add("".concat(HTML_CLASS_I2SVG_BASE_CLASS, "-").concat(suffix));
1994	    };
1995
1996	    var hclRemove = function hclRemove(suffix) {
1997	      return htmlClassList.remove("".concat(HTML_CLASS_I2SVG_BASE_CLASS, "-").concat(suffix));
1998	    };
1999
2000	    var prefixes = config.autoFetchSvg ? Object.keys(PREFIX_TO_STYLE) : Object.keys(styles$3);
2001	    var prefixesDomQuery = [".".concat(LAYERS_TEXT_CLASSNAME, ":not([").concat(DATA_FA_I2SVG, "])")].concat(prefixes.map(function (p) {
2002	      return ".".concat(p, ":not([").concat(DATA_FA_I2SVG, "])");
2003	    })).join(', ');
2004
2005	    if (prefixesDomQuery.length === 0) {
2006	      return;
2007	    }
2008
2009	    var candidates = toArray(root.querySelectorAll(prefixesDomQuery));
2010
2011	    if (candidates.length > 0) {
2012	      hclAdd('pending');
2013	      hclRemove('complete');
2014	    } else {
2015	      return;
2016	    }
2017
2018	    var mark = perf.begin('onTree');
2019	    var mutations = candidates.reduce(function (acc, node) {
2020	      try {
2021	        var mutation = generateMutation(node);
2022
2023	        if (mutation) {
2024	          acc.push(mutation);
2025	        }
2026	      } catch (e) {
2027	        if (!PRODUCTION) {
2028	          if (e instanceof MissingIcon) {
2029	            console.error(e);
2030	          }
2031	        }
2032	      }
2033
2034	      return acc;
2035	    }, []);
2036	    return new picked(function (resolve, reject) {
2037	      picked.all(mutations).then(function (resolvedMutations) {
2038	        perform(resolvedMutations, function () {
2039	          hclAdd('active');
2040	          hclAdd('complete');
2041	          hclRemove('pending');
2042	          if (typeof callback === 'function') callback();
2043	          mark();
2044	          resolve();
2045	        });
2046	      }).catch(function () {
2047	        mark();
2048	        reject();
2049	      });
2050	    });
2051	  }
2052	  function onNode(node) {
2053	    var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
2054	    generateMutation(node).then(function (mutation) {
2055	      if (mutation) {
2056	        perform([mutation], callback);
2057	      }
2058	    });
2059	  }
2060
2061	  function replaceForPosition(node, position) {
2062	    var pendingAttribute = "".concat(DATA_FA_PSEUDO_ELEMENT_PENDING).concat(position.replace(':', '-'));
2063	    return new picked(function (resolve, reject) {
2064	      if (node.getAttribute(pendingAttribute) !== null) {
2065	        // This node is already being processed
2066	        return resolve();
2067	      }
2068
2069	      var children = toArray(node.children);
2070	      var alreadyProcessedPseudoElement = children.filter(function (c) {
2071	        return c.getAttribute(DATA_FA_PSEUDO_ELEMENT) === position;
2072	      })[0];
2073	      var styles = WINDOW.getComputedStyle(node, position);
2074	      var fontFamily = styles.getPropertyValue('font-family').match(FONT_FAMILY_PATTERN);
2075	      var fontWeight = styles.getPropertyValue('font-weight');
2076
2077	      if (alreadyProcessedPseudoElement && !fontFamily) {
2078	        // If we've already processed it but the current computed style does not result in a font-family,
2079	        // that probably means that a class name that was previously present to make the icon has been
2080	        // removed. So we now should delete the icon.
2081	        node.removeChild(alreadyProcessedPseudoElement);
2082	        return resolve();
2083	      } else if (fontFamily) {
2084	        var content = styles.getPropertyValue('content');
2085	        var prefix = ~['Light', 'Regular', 'Solid', 'Brands'].indexOf(fontFamily[1]) ? STYLE_TO_PREFIX[fontFamily[1].toLowerCase()] : FONT_WEIGHT_TO_PREFIX[fontWeight];
2086	        var iconName = byUnicode(prefix, toHex(content.length === 3 ? content.substr(1, 1) : content)); // Only convert the pseudo element in this :before/:after position into an icon if we haven't
2087	        // already done so with the same prefix and iconName
2088
2089	        if (!alreadyProcessedPseudoElement || alreadyProcessedPseudoElement.getAttribute(DATA_PREFIX) !== prefix || alreadyProcessedPseudoElement.getAttribute(DATA_ICON) !== iconName) {
2090	          node.setAttribute(pendingAttribute, iconName);
2091
2092	          if (alreadyProcessedPseudoElement) {
2093	            // Delete the old one, since we're replacing it with a new one
2094	            node.removeChild(alreadyProcessedPseudoElement);
2095	          }
2096
2097	          var meta = blankMeta();
2098	          var extra = meta.extra;
2099	          extra.attributes[DATA_FA_PSEUDO_ELEMENT] = position;
2100	          findIcon(iconName, prefix).then(function (main) {
2101	            var abstract = makeInlineSvgAbstract(_objectSpread({}, meta, {
2102	              icons: {
2103	                main: main,
2104	                mask: emptyCanonicalIcon()
2105	              },
2106	              prefix: prefix,
2107	              iconName: iconName,
2108	              extra: extra,
2109	              watchable: true
2110	            }));
2111	            var element = DOCUMENT.createElement('svg');
2112
2113	            if (position === ':before') {
2114	              node.insertBefore(element, node.firstChild);
2115	            } else {
2116	              node.appendChild(element);
2117	            }
2118
2119	            element.outerHTML = abstract.map(function (a) {
2120	              return toHtml(a);
2121	            }).join('\n');
2122	            node.removeAttribute(pendingAttribute);
2123	            resolve();
2124	          }).catch(reject);
2125	        } else {
2126	          resolve();
2127	        }
2128	      } else {
2129	        resolve();
2130	      }
2131	    });
2132	  }
2133
2134	  function replace(node) {
2135	    return picked.all([replaceForPosition(node, ':before'), replaceForPosition(node, ':after')]);
2136	  }
2137
2138	  function processable(node) {
2139	    return node.parentNode !== document.head && !~TAGNAMES_TO_SKIP_FOR_PSEUDOELEMENTS.indexOf(node.tagName.toUpperCase()) && !node.getAttribute(DATA_FA_PSEUDO_ELEMENT) && (!node.parentNode || node.parentNode.tagName !== 'svg');
2140	  }
2141
2142	  function searchPseudoElements (root) {
2143	    if (!IS_DOM) return;
2144	    return new picked(function (resolve, reject) {
2145	      var operations = toArray(root.querySelectorAll('*')).filter(processable).map(replace);
2146	      var end = perf.begin('searchPseudoElements');
2147	      disableObservation();
2148	      picked.all(operations).then(function () {
2149	        end();
2150	        enableObservation();
2151	        resolve();
2152	      }).catch(function () {
2153	        end();
2154	        enableObservation();
2155	        reject();
2156	      });
2157	    });
2158	  }
2159
2160	  var baseStyles = "svg:not(:root).svg-inline--fa {\n  overflow: visible;\n}\n\n.svg-inline--fa {\n  display: inline-block;\n  font-size: inherit;\n  height: 1em;\n  overflow: visible;\n  vertical-align: -0.125em;\n}\n.svg-inline--fa.fa-lg {\n  vertical-align: -0.225em;\n}\n.svg-inline--fa.fa-w-1 {\n  width: 0.0625em;\n}\n.svg-inline--fa.fa-w-2 {\n  width: 0.125em;\n}\n.svg-inline--fa.fa-w-3 {\n  width: 0.1875em;\n}\n.svg-inline--fa.fa-w-4 {\n  width: 0.25em;\n}\n.svg-inline--fa.fa-w-5 {\n  width: 0.3125em;\n}\n.svg-inline--fa.fa-w-6 {\n  width: 0.375em;\n}\n.svg-inline--fa.fa-w-7 {\n  width: 0.4375em;\n}\n.svg-inline--fa.fa-w-8 {\n  width: 0.5em;\n}\n.svg-inline--fa.fa-w-9 {\n  width: 0.5625em;\n}\n.svg-inline--fa.fa-w-10 {\n  width: 0.625em;\n}\n.svg-inline--fa.fa-w-11 {\n  width: 0.6875em;\n}\n.svg-inline--fa.fa-w-12 {\n  width: 0.75em;\n}\n.svg-inline--fa.fa-w-13 {\n  width: 0.8125em;\n}\n.svg-inline--fa.fa-w-14 {\n  width: 0.875em;\n}\n.svg-inline--fa.fa-w-15 {\n  width: 0.9375em;\n}\n.svg-inline--fa.fa-w-16 {\n  width: 1em;\n}\n.svg-inline--fa.fa-w-17 {\n  width: 1.0625em;\n}\n.svg-inline--fa.fa-w-18 {\n  width: 1.125em;\n}\n.svg-inline--fa.fa-w-19 {\n  width: 1.1875em;\n}\n.svg-inline--fa.fa-w-20 {\n  width: 1.25em;\n}\n.svg-inline--fa.fa-pull-left {\n  margin-right: 0.3em;\n  width: auto;\n}\n.svg-inline--fa.fa-pull-right {\n  margin-left: 0.3em;\n  width: auto;\n}\n.svg-inline--fa.fa-border {\n  height: 1.5em;\n}\n.svg-inline--fa.fa-li {\n  width: 2em;\n}\n.svg-inline--fa.fa-fw {\n  width: 1.25em;\n}\n\n.fa-layers svg.svg-inline--fa {\n  bottom: 0;\n  left: 0;\n  margin: auto;\n  position: absolute;\n  right: 0;\n  top: 0;\n}\n\n.fa-layers {\n  display: inline-block;\n  height: 1em;\n  position: relative;\n  text-align: center;\n  vertical-align: -0.125em;\n  width: 1em;\n}\n.fa-layers svg.svg-inline--fa {\n  -webkit-transform-origin: center center;\n          transform-origin: center center;\n}\n\n.fa-layers-counter, .fa-layers-text {\n  display: inline-block;\n  position: absolute;\n  text-align: center;\n}\n\n.fa-layers-text {\n  left: 50%;\n  top: 50%;\n  -webkit-transform: translate(-50%, -50%);\n          transform: translate(-50%, -50%);\n  -webkit-transform-origin: center center;\n          transform-origin: center center;\n}\n\n.fa-layers-counter {\n  background-color: #ff253a;\n  border-radius: 1em;\n  -webkit-box-sizing: border-box;\n          box-sizing: border-box;\n  color: #fff;\n  height: 1.5em;\n  line-height: 1;\n  max-width: 5em;\n  min-width: 1.5em;\n  overflow: hidden;\n  padding: 0.25em;\n  right: 0;\n  text-overflow: ellipsis;\n  top: 0;\n  -webkit-transform: scale(0.25);\n          transform: scale(0.25);\n  -webkit-transform-origin: top right;\n          transform-origin: top right;\n}\n\n.fa-layers-bottom-right {\n  bottom: 0;\n  right: 0;\n  top: auto;\n  -webkit-transform: scale(0.25);\n          transform: scale(0.25);\n  -webkit-transform-origin: bottom right;\n          transform-origin: bottom right;\n}\n\n.fa-layers-bottom-left {\n  bottom: 0;\n  left: 0;\n  right: auto;\n  top: auto;\n  -webkit-transform: scale(0.25);\n          transform: scale(0.25);\n  -webkit-transform-origin: bottom left;\n          transform-origin: bottom left;\n}\n\n.fa-layers-top-right {\n  right: 0;\n  top: 0;\n  -webkit-transform: scale(0.25);\n          transform: scale(0.25);\n  -webkit-transform-origin: top right;\n          transform-origin: top right;\n}\n\n.fa-layers-top-left {\n  left: 0;\n  right: auto;\n  top: 0;\n  -webkit-transform: scale(0.25);\n          transform: scale(0.25);\n  -webkit-transform-origin: top left;\n          transform-origin: top left;\n}\n\n.fa-lg {\n  font-size: 1.3333333333em;\n  line-height: 0.75em;\n  vertical-align: -0.0667em;\n}\n\n.fa-xs {\n  font-size: 0.75em;\n}\n\n.fa-sm {\n  font-size: 0.875em;\n}\n\n.fa-1x {\n  font-size: 1em;\n}\n\n.fa-2x {\n  font-size: 2em;\n}\n\n.fa-3x {\n  font-size: 3em;\n}\n\n.fa-4x {\n  font-size: 4em;\n}\n\n.fa-5x {\n  font-size: 5em;

2193	          definitions[_key] = arguments[_key];
2194	        }
2195
2196	        var additions = definitions.reduce(this._pullDefinitions, {});
2197	        Object.keys(additions).forEach(function (key) {
2198	          _this.definitions[key] = _objectSpread({}, _this.definitions[key] || {}, additions[key]);
2199	          defineIcons(key, additions[key]);
2200	          build();
2201	        });
2202	      }
2203	    }, {
2204	      key: "reset",
2205	      value: function reset() {
2206	        this.definitions = {};
2207	      }
2208	    }, {
2209	      key: "_pullDefinitions",
2210	      value: function _pullDefinitions(additions, definition) {
2211	        var normalized = definition.prefix && definition.iconName && definition.icon ? {
2212	          0: definition
2213	        } : definition;
2214	        Object.keys(normalized).map(function (key) {
2215	          var _normalized$key = normalized[key],
2216	              prefix = _normalized$key.prefix,
2217	              iconName = _normalized$key.iconName,
2218	              icon = _normalized$key.icon;
2219	          if (!additions[prefix]) additions[prefix] = {};
2220	          additions[prefix][iconName] = icon;
2221	        });
2222	        return additions;
2223	      }
2224	    }]);
2225
2226	    return Library;
2227	  }();
2228
2229	  function prepIcon(icon) {
2230	    var width = icon[0];
2231	    var height = icon[1];
2232	    var vectorData = icon.slice(4);
2233	    return {
2234	      found: true,
2235	      width: width,
2236	      height: height,
2237	      icon: {
2238	        tag: 'path',
2239	        attributes: {
2240	          fill: 'currentColor',
2241	          d: vectorData[0]
2242	        }
2243	      }
2244	    };
2245	  }
2246
2247	  function ensureCss() {
2248	    if (config.autoAddCss && !_cssInserted) {
2249	      insertCss(css());
2250
2251	      _cssInserted = true;
2252	    }
2253	  }
2254
2255	  function apiObject(val, abstractCreator) {
2256	    Object.defineProperty(val, 'abstract', {
2257	      get: abstractCreator
2258	    });
2259	    Object.defineProperty(val, 'html', {
2260	      get: function get() {
2261	        return val.abstract.map(function (a) {
2262	          return toHtml(a);
2263	        });
2264	      }
2265	    });
2266	    Object.defineProperty(val, 'node', {
2267	      get: function get() {
2268	        if (!IS_DOM) return;
2269	        var container = DOCUMENT.createElement('div');
2270	        container.innerHTML = val.html;
2271	        return container.children;
2272	      }
2273	    });
2274	    return val;
2275	  }
2276
2277	  function findIconDefinition(iconLookup) {
2278	    var _iconLookup$prefix = iconLookup.prefix,
2279	        prefix = _iconLookup$prefix === void 0 ? 'fa' : _iconLookup$prefix,
2280	        iconName = iconLookup.iconName;
2281	    if (!iconName) return;
2282	    return iconFromMapping(library.definitions, prefix, iconName) || iconFromMapping(namespace.styles, prefix, iconName);
2283	  }
2284
2285	  function resolveIcons(next) {
2286	    return function (maybeIconDefinition) {
2287	      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2288	      var iconDefinition = (maybeIconDefinition || {}).icon ? maybeIconDefinition : findIconDefinition(maybeIconDefinition || {});
2289	      var mask = params.mask;
2290
2291	      if (mask) {
2292	        mask = (mask || {}).icon ? mask : findIconDefinition(mask || {});
2293	      }
2294
2295	      return next(iconDefinition, _objectSpread({}, params, {
2296	        mask: mask
2297	      }));
2298	    };
2299	  }
2300
2301	  var library = new Library();
2302	  var noAuto = function noAuto() {
2303	    config.autoReplaceSvg = false;
2304	    config.observeMutations = false;
2305	    disconnect();
2306	  };
2307	  var _cssInserted = false;
2308	  var dom = {
2309	    i2svg: function i2svg() {
2310	      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2311
2312	      if (IS_DOM) {
2313	        ensureCss();
2314	        var _params$node = params.node,
2315	            node = _params$node === void 0 ? DOCUMENT : _params$node,
2316	            _params$callback = params.callback,
2317	            callback = _params$callback === void 0 ? function () {} : _params$callback;
2318
2319	        if (config.searchPseudoElements) {
2320	          searchPseudoElements(node);
2321	        }
2322
2323	        return onTree(node, callback);
2324	      } else {
2325	        return picked.reject('Operation requires a DOM of some kind.');
2326	      }
2327	    },
2328	    css: css,
2329	    insertCss: function insertCss$$1() {
2330	      if (!_cssInserted) {
2331	        insertCss(css());
2332
2333	        _cssInserted = true;
2334	      }
2335	    },
2336	    watch: function watch() {
2337	      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2338	      var autoReplaceSvgRoot = params.autoReplaceSvgRoot,
2339	          observeMutationsRoot = params.observeMutationsRoot;
2340
2341	      if (config.autoReplaceSvg === false) {
2342	        config.autoReplaceSvg = true;
2343	      }
2344
2345	      config.observeMutations = false;
2346	      domready(function () {
2347	        autoReplace({
2348	          autoReplaceSvgRoot: autoReplaceSvgRoot
2349	        });
2350	        observe({
2351	          treeCallback: onTree,
2352	          nodeCallback: onNode,
2353	          pseudoElementsCallback: searchPseudoElements,
2354	          observeMutationsRoot: observeMutationsRoot
2355	        });
2356	      });
2357	    }
2358	  };
2359	  var parse = {
2360	    transform: function transform(transformString) {
2361	      return parseTransformString(transformString);
2362	    }
2363	  };
2364	  var icon = resolveIcons(function (iconDefinition) {
2365	    var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2366	    var _params$transform = params.transform,
2367	        transform = _params$transform === void 0 ? meaninglessTransform : _params$transform,
2368	        _params$symbol = params.symbol,
2369	        symbol = _params$symbol === void 0 ? false : _params$symbol,
2370	        _params$mask = params.mask,
2371	        mask = _params$mask === void 0 ? null : _params$mask,
2372	        _params$title = params.title,
2373	        title = _params$title === void 0 ? null : _params$title,
2374	        _params$classes = params.classes,
2375	        classes = _params$classes === void 0 ? [] : _params$classes,
2376	        _params$attributes = params.attributes,
2377	        attributes = _params$attributes === void 0 ? {} : _params$attributes,
2378	        _params$styles = params.styles,
2379	        styles = _params$styles === void 0 ? {} : _params$styles;
2380	    if (!iconDefinition) return;
2381	    var prefix = iconDefinition.prefix,
2382	        iconName = iconDefinition.iconName,
2383	        icon = iconDefinition.icon;
2384	    return apiObject(_objectSpread({
2385	      type: 'icon'
2386	    }, iconDefinition), function () {
2387	      ensureCss();
2388
2389	      if (config.autoA11y) {
2390	        if (title) {
2391	          attributes['aria-labelledby'] = "".concat(config.replacementClass, "-title-").concat(nextUniqueId());
2392	        } else {
2393	          attributes['aria-hidden'] = 'true';
2394	          attributes['focusable'] = 'false';
2395	        }
2396	      }
2397
2398	      return makeInlineSvgAbstract({
2399	        icons: {
2400	          main: prepIcon(icon),
2401	          mask: mask ? prepIcon(mask.icon) : {
2402	            found: false,
2403	            width: null,
2404	            height: null,
2405	            icon: {}
2406	          }
2407	        },
2408	        prefix: prefix,
2409	        iconName: iconName,
2410	        transform: _objectSpread({}, meaninglessTransform, transform),
2411	        symbol: symbol,
2412	        title: title,
2413	        extra: {
2414	          attributes: attributes,
2415	          styles: styles,
2416	          classes: classes
2417	        }
2418	      });
2419	    });
2420	  });
2421	  var text = function text(content) {
2422	    var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2423	    var _params$transform2 = params.transform,
2424	        transform = _params$transform2 === void 0 ? meaninglessTransform : _params$transform2,
2425	        _params$title2 = params.title,
2426	        title = _params$title2 === void 0 ? null : _params$title2,
2427	        _params$classes2 = params.classes,
2428	        classes = _params$classes2 === void 0 ? [] : _params$classes2,
2429	        _params$attributes2 = params.attributes,
2430	        attributes = _params$attributes2 === void 0 ? {} : _params$attributes2,
2431	        _params$styles2 = params.styles,
2432	        styles = _params$styles2 === void 0 ? {} : _params$styles2;
2433	    return apiObject({
2434	      type: 'text',
2435	      content: content
2436	    }, function () {
2437	      ensureCss();
2438	      return makeLayersTextAbstract({
2439	        content: content,
2440	        transform: _objectSpread({}, meaninglessTransform, transform),
2441	        title: title,
2442	        extra: {
2443	          attributes: attributes,
2444	          styles: styles,
2445	          classes: ["".concat(config.familyPrefix, "-layers-text")].concat(_toConsumableArray(classes))
2446	        }
2447	      });
2448	    });
2449	  };
2450	  var counter = function counter(content) {
2451	    var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2452	    var _params$title3 = params.title,
2453	        title = _params$title3 === void 0 ? null : _params$title3,
2454	        _params$classes3 = params.classes,
2455	        classes = _params$classes3 === void 0 ? [] : _params$classes3,
2456	        _params$attributes3 = params.attributes,
2457	        attributes = _params$attributes3 === void 0 ? {} : _params$attributes3,
2458	        _params$styles3 = params.styles,
2459	        styles = _params$styles3 === void 0 ? {} : _params$styles3;
2460	    return apiObject({
2461	      type: 'counter',
2462	      content: content
2463	    }, function () {
2464	      ensureCss();
2465	      return makeLayersCounterAbstract({
2466	        content: content.toString(),
2467	        title: title,
2468	        extra: {
2469	          attributes: attributes,
2470	          styles: styles,
2471	          classes: ["".concat(config.familyPrefix, "-layers-counter")].concat(_toConsumableArray(classes))
2472	        }
2473	      });
2474	    });
2475	  };
2476	  var layer = function layer(assembler) {
2477	    return apiObject({
2478	      type: 'layer'
2479	    }, function () {
2480	      ensureCss();
2481	      var children = [];
2482	      assembler(function (args) {
2483	        Array.isArray(args) ? args.map(function (a) {
2484	          children = children.concat(a.abstract);
2485	        }) : children = children.concat(args.abstract);
2486	      });
2487	      return [{
2488	        tag: 'span',
2489	        attributes: {
2490	          class: "".concat(config.familyPrefix, "-layers")
2491	        },
2492	        children: children
2493	      }];
2494	    });
2495	  };
2496	  var api = {
2497	    noAuto: noAuto,
2498	    config: config,
2499	    dom: dom,
2500	    library: library,
2501	    parse: parse,
2502	    findIconDefinition: findIconDefinition,
2503	    icon: icon,
2504	    text: text,
2505	    counter: counter,
2506	    layer: layer,
2507	    toHtml: toHtml
2508	  };
2509
2510	  var autoReplace = function autoReplace() {
2511	    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2512	    var _params$autoReplaceSv = params.autoReplaceSvgRoot,
2513	        autoReplaceSvgRoot = _params$autoReplaceSv === void 0 ? DOCUMENT : _params$autoReplaceSv;
2514	    if ((Object.keys(namespace.styles).length > 0 || config.autoFetchSvg) && IS_DOM && config.autoReplaceSvg) api.dom.i2svg({
2515	      node: autoReplaceSvgRoot
2516	    });
2517	  };
2518
2519	  exports.icon = icon;
2520	  exports.noAuto = noAuto;
2521	  exports.config = config;
2522	  exports.toHtml = toHtml;
2523	  exports.layer = layer;
2524	  exports.text = text;
2525	  exports.counter = counter;
2526	  exports.library = library;
2527	  exports.dom = dom;
2528	  exports.parse = parse;
2529	  exports.findIconDefinition = findIconDefinition;
2530
2531	  Object.defineProperty(exports, '__esModule', { value: true });
2532
2533	})));
2534
2535	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), (function() { return this; }()

2535), __webpack_require__(4).setImmediate))
2536
2537/***/ }),
2538/* 3 */
2539/***/ (function(module, exports) {
2540
2541	// shim for using process in browser
2542	var process = module.exports = {};
2543
2544	// cached from whatever global is present so that test runners that stub it
2545	// don't break things.  But we need to wrap it in a try catch in case it is
2546	// wrapped in strict mode code which doesn't define any globals.  It's inside a
2547	// function because try/catches deoptimize in certain engines.
2548
2549	var cachedSetTimeout;
2550	var cachedClearTimeout;
2551
2552	function defaultSetTimout() {
2553	    throw new Error('setTimeout has not been defined');
2554	}
2555	function defaultClearTimeout () {
2556	    throw new Error('clearTimeout has not been defined');
2557	}
2558	(function () {
2559	    try {
2560	        if (typeof setTimeout === 'function') {
2561	            cachedSetTimeout = setTimeout;
2562	        } else {
2563	            cachedSetTimeout = defaultSetTimout;
2564	        }
2565	    } catch (e) {
2566	        cachedSetTimeout = defaultSetTimout;
2567	    }
2568	    try {
2569	        if (typeof clearTimeout === 'function') {
2570	            cachedClearTimeout = clearTimeout;
2571	        } else {
2572	            cachedClearTimeout = defaultClearTimeout;
2573	        }
2574	    } catch (e) {
2575	        cachedClearTimeout = defaultClearTimeout;
2576	    }
2577	} ())
2578	function runTimeout(fun) {
2579	    if (cachedSetTimeout === setTimeout) {
2580	        //normal enviroments in sane situations
2581	        return setTimeout(fun, 0);
2582	    }
2583	    // if setTimeout wasn't available but was latter defined
2584	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
2585	        cachedSetTimeout = setTimeout;
2586	        return setTimeout(fun, 0);
2587	    }
2588	    try {
2589	        // when when somebody has screwed with setTimeout but no I.E. maddness
2590	        return cachedSetTimeout(fun, 0);
2591	    } catch(e){
2592	        try {
2593	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
2594	            return cachedSetTimeout.call(null, fun, 0);
2595	        } catch(e){
2596	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
2597	            return cachedSetTimeout.call(this, fun, 0);
2598	        }
2599	    }
2600
2601
2602	}
2603	function runClearTimeout(marker) {
2604	    if (cachedClearTimeout === clearTimeout) {
2605	        //normal enviroments in sane situations
2606	        return clearTimeout(marker);
2607	    }
2608	    // if clearTimeout wasn't available but was latter defined
2609	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
2610	        cachedClearTimeout = clearTimeout;
2611	        return clearTimeout(marker);
2612	    }
2613	    try {
2614	        // when when somebody has screwed with setTimeout but no I.E. maddness
2615	        return cachedClearTimeout(marker);
2616	    } catch (e){
2617	        try {
2618	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
2619	            return cachedClearTimeout.call(null, marker);
2620	        } catch (e){
2621	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
2622	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
2623	            return cachedClearTimeout.call(this, marker);
2624	        }
2625	    }
2626
2627
2628
2629	}
2630	var queue = [];
2631	var draining = false;
2632	var currentQueue;
2633	var queueIndex = -1;
2634
2635	function cleanUpNextTick() {
2636	    if (!draining || !currentQueue) {
2637	        return;
2638	    }
2639	    draining = false;
2640	    if (currentQueue.length) {
2641	        queue = currentQueue.concat(queue);
2642	    } else {
2643	        queueIndex = -1;
2644	    }
2645	    if (queue.length) {
2646	        drainQueue();
2647	    }
2648	}
2649
2650	function drainQueue() {
2651	    if (draining) {
2652	        return;
2653	    }
2654	    var timeout = runTimeout(cleanUpNextTick);
2655	    draining = true;
2656
2657	    var len = queue.length;
2658	    while(len) {
2659	        currentQueue = queue;
2660	        queue = [];
2661	        while (++queueIndex < len) {
2662	            if (currentQueue) {
2663	                currentQueue[queueIndex].run();
2664	            }
2665	        }
2666	        queueIndex = -1;
2667	        len = queue.length;
2668	    }
2669	    currentQueue = null;
2670	    draining = false;
2671	    runClearTimeout(timeout);
2672	}
2673
2674	process.nextTick = function (fun) {
2675	    var args = new Array(arguments.length - 1);
2676	    if (arguments.length > 1) {
2677	        for (var i = 1; i < arguments.length; i++) {
2678	            args[i - 1] = arguments[i];
2679	        }
2680	    }
2681	    queue.push(new Item(fun, args));
2682	    if (queue.length === 1 && !draining) {
2683	        runTimeout(drainQueue);
2684	    }
2685	};
2686
2687	// v8 likes predictible objects
2688	function Item(fun, array) {
2689	    this.fun = fun;
2690	    this.array = array;
2691	}
2692	Item.prototype.run = function () {
2693	    this.fun.apply(null, this.array);
2694	};
2695	process.title = 'browser';
2696	process.browser = true;
2697	process.env = {};
2698	process.argv = [];
2699	process.version = ''; // empty string to avoid regexp issues
2700	process.versions = {};
2701
2702	function noop() {}
2703
2704	process.on = noop;
2705	process.addListener = noop;
2706	process.once = noop;
2707	process.off = noop;
2708	process.removeListener = noop;
2709	process.removeAllListeners = noop;
2710	process.emit = noop;
2711	process.prependListener = noop;
2712	process.prependOnceListener = noop;
2713
2714	process.listeners = function (name) { return [] }
2715
2716	process.binding = function (name) {
2717	    throw new Error('process.binding is not supported');
2718	};
2719
2720	process.cwd = function () { return '/' };
2721	process.chdir = function (dir) {
2722	    throw new Error('process.chdir is not supported');
2723	};
2724	process.umask = function() { return 0; };
2725
2726
2727/***/ }),
2728/* 4 */
2729/***/ (function(module, exports, __webpack_require__) {
2730
2731	/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
2732	            (typeof self !== "undefined" && self) ||
2733	            window;
2734	var apply = Function.prototype.apply;
2735
2736	// DOM APIs, for completeness
2737
2738	exports.setTimeout = function() {
2739	  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
2740	};
2741	exports.setInterval = function() {
2742	  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
2743	};
2744	exports.clearTimeout =
2745	exports.clearInterval = function(timeout) {
2746	  if (timeout) {
2747	    timeout.close();
2748	  }
2749	};
2750
2751	function Timeout(id, clearFn) {
2752	  this._id = id;
2753	  this._clearFn = clearFn;
2754	}
2755	Timeout.prototype.unref = Timeout.prototype.ref = function() {};
2756	Timeout.prototype.close = function() {
2757	  this._clearFn.call(scope, this._id);
2758	};
2759
2760	// Does not start the time, just sets up the members needed.
2761	exports.enroll = function(item, msecs) {
2762	  clearTimeout(item._idleTimeoutId);
2763	  item._idleTimeout = msecs;
2764	};
2765
2766	exports.unenroll = function(item) {
2767	  clearTimeout(item._idleTimeoutId);
2768	  item._idleTimeout = -1;
2769	};
2770
2771	exports._unrefActive = exports.active = function(item) {
2772	  clearTimeout(item._idleTimeoutId);
2773
2774	  var msecs = item._idleTimeout;
2775	  if (msecs >= 0) {
2776	    item._idleTimeoutId = setTimeout(function onTimeout() {
2777	      if (item._onTimeout)
2778	        item._onTimeout();
2779	    }, msecs);
2780	  }
2781	};
2782
2783	// setimmediate attaches itself to the global object
2784	__webpack_require__(5);
2785	// On some exotic environments, it's not clear which object `setimmediate` was
2786	// able to install onto.  Search each possibility in the same order as the
2787	// `setimmediate` library.
2788	exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
2789	                       (typeof global !== "undefined" && global.setImmediate) ||
2790	                       (this && this.setImmediate);
2791	exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
2792	                         (typeof global !== "undefined" && global.clearImmediate) ||
2793	                         (this && this.clearImmediate);
2794
2795	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
2796
2797/***/ }),
2798/* 5 */
2799/***/ (function(module, exports, __webpack_require__) {
2800
2801	/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
2802	    "use strict";
2803
2804	    if (global.setImmediate) {
2805	        return;
2806	    }
2807
2808	    var nextHandle = 1; // Spec says greater than zero
2809	    var tasksByHandle = {};
2810	    var currentlyRunningATask = false;
2811	    var doc = global.document;
2812	    var registerImmediate;
2813
2814	    function setImmediate(callback) {
2815	      // Callback can either be a function or a string
2816	      if (typeof callback !== "function") {
2817	        callback = new Function("" + callback);
2818	      }
2819	      // Copy function arguments
2820	      var args = new Array(arguments.length - 1);
2821	      for (var i = 0; i < args.length; i++) {
2822	          args[i] = arguments[i + 1];
2823	      }
2824	      // Store and register the task
2825	      var task = { callback: callback, args: args };
2826	      tasksByHandle[nextHandle] = task;
2827	      registerImmediate(nextHandle);
2828	      return nextHandle++;
2829	    }
2830
2831	    function clearImmediate(handle) {
2832	        delete tasksByHandle[handle];
2833	    }
2834
2835	    function run(task) {
2836	        var callback = task.callback;
2837	        var args = task.args;
2838	        switch (args.length) {
2839	        case 0:
2840	            callback();
2841	            break;
2842	        case 1:
2843	            callback(args[0]);
2844	            break;
2845	        case 2:
2846	            callback(args[0], args[1]);
2847	            break;
2848	        case 3:
2849	            callback(args[0], args[1], args[2]);
2850	            break;
2851	        default:
2852	            callback.apply(undefined, args);
2853	            break;
2854	        }
2855	    }
2856
2857	    function runIfPresent(handle) {
2858	        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
2859	        // So if we're currently running a task, we'll need to delay this invocation.
2860	        if (currentlyRunningATask) {
2861	            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
2862	            // "too much recursion" error.
2863	            setTimeout(runIfPresent, 0, handle);
2864	        } else {
2865	            var task = tasksByHandle[handle];
2866	            if (task) {
2867	                currentlyRunningATask = true;
2868	                try {
2869	                    run(task);
2870	                } finally {
2871	                    clearImmediate(handle);
2872	                    currentlyRunningATask = false;
2873	                }
2874	            }
2875	        }
2876	    }
2877
2878	    function installNextTickImplementation() {
2879	        registerImmediate = function(handle) {
2880	            process.nextTick(function () { runIfPresent(handle); });
2881	        };
2882	    }
2883
2884	    function canUsePostMessage() {
2885	        // The test against `importScripts` prevents this implementation from being installed inside a web worker,
2886	        // where `global.postMessage` means something completely different and can't be used for this purpose.
2887	        if (global.postMessage && !global.importScripts) {
2888	            var postMessageIsAsynchronous = true;
2889	            var oldOnMessage = global.onmessage;
2890	            global.onmessage = function() {
2891	                postMessageIsAsynchronous = false;
2892	            };
2893	            global.postMessage("", "*");
2894	            global.onmessage = oldOnMessage;
2895	            return postMessageIsAsynchronous;
2896	        }
2897	    }
2898
2899	    function installPostMessageImplementation() {
2900	        // Installs an event handler on `global` for the `message` event: see
2901	        // * https://developer.mozilla.org/en/DOM/window.postMessage
2902	        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
2903
2904	        var messagePrefix = "setImmediate$" + Math.random() + "$";
2905	        var onGlobalMessage = function(event) {
2906	            if (event.source === global &&
2907	                typeof event.data === "string" &&
2908	                event.data.indexOf(messagePrefix) === 0) {
2909	                runIfPresent(+event.data.slice(messagePrefix.length));
2910	            }
2911	        };
2912
2913	        if (global.addEventListener) {
2914	            global.addEventListener("message", onGlobalMessage, false);
2915	        } else {
2916	            global.attachEvent("onmessage", onGlobalMessage);
2917	        }
2918
2919	        registerImmediate = function(handle) {
2920	            global.postMessage(messagePrefix + handle, "*");
2921	        };
2922	    }
2923
2924	    function installMessageChannelImplementation() {
2925	        var channel = new MessageChannel();
2926	        channel.port1.onmessage = function(event) {
2927	            var handle = event.data;
2928	            runIfPresent(handle);
2929	        };
2930
2931	        registerImmediate = function(handle) {
2932	            channel.port2.postMessage(handle);
2933	        };
2934	    }
2935
2936	    function installReadyStateChangeImplementation() {
2937	        var html = doc.documentElement;
2938	        registerImmediate = function(handle) {
2939	            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
2940	            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
2941	            var script = doc.createElement("script");
2942	            script.onreadystatechange = function () {
2943	                runIfPresent(handle);
2944	                script.onreadystatechange = null;
2945	                html.removeChild(script);
2946	                script = null;
2947	            };
2948	            html.appendChild(script);
2949	        };
2950	    }
2951
2952	    function installSetTimeoutImplementation() {
2953	        registerImmediate = function(handle) {
2954	            setTimeout(runIfPresent, 0, handle);
2955	        };
2956	    }
2957
2958	    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
2959	    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
2960	    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
2961
2962	    // Don't get fooled by e.g. browserify environments.
2963	    if ({}.toString.call(global.process) === "[object process]") {
2964	        // For Node.js before 0.9
2965	        installNextTickImplementation();
2966
2967	    } else if (canUsePostMessage()) {
2968	        // For non-IE10 modern browsers
2969	        installPostMessageImplementation();
2970
2971	    } else if (global.MessageChannel) {
2972	        // For web workers, where supported
2973	        installMessageChannelImplementation();
2974
2975	    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
2976	        // For IE 6–8
2977	        installReadyStateChangeImplementation();
2978
2979	    } else {
2980	        // For older browsers
2981	        installSetTimeoutImplementation();
2982	    }
2983
2984	    attachTo.setImmediate = setImmediate;
2985	    attachTo.clearImmediate = clearImmediate;
2986	}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
2987
2988	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(3)))
2989
2990/***/ }),
2991/* 6 */
2992/***/ (function(module, exports